diff --git a/.gitignore b/.gitignore index 53eaa21..12735bf 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ /target **/*.rs.bk +lib/**/target \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index ae83b0e..96156e2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -13,6 +13,20 @@ name = "bitflags" version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" +[[package]] +name = "byteorder" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "bytes" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", + "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "cfg-if" version = "0.1.9" @@ -31,6 +45,15 @@ name = "glob" version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" +[[package]] +name = "iovec" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "ipnetwork" version = "0.14.0" @@ -170,6 +193,9 @@ dependencies = [ [[package]] name = "protocol16" version = "0.1.0" +dependencies = [ + "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)", +] [[package]] name = "regex" @@ -300,8 +326,11 @@ dependencies = [ [metadata] "checksum aho-corasick 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5" "checksum bitflags 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4f67931368edf3a9a51d29886d245f1c3db2f1ef0dcc9e35ff70341b78c10d23" +"checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5" +"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c" "checksum cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "b486ce3ccf7ffd79fdeb678eac06a9e6c09fc88d33836340becb8fffe87c5e33" "checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb" +"checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08" "checksum ipnetwork 0.14.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b3d862c86f7867f19b693ec86765e0252d82e53d4240b9b629815675a0714ad1" "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d" "checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14" diff --git a/lib/protocol16/Cargo.lock b/lib/protocol16/Cargo.lock new file mode 100644 index 0000000..6e18a0d --- /dev/null +++ b/lib/protocol16/Cargo.lock @@ -0,0 +1,48 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +[[package]] +name = "byteorder" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "bytes" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", + "iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "iovec" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "libc" +version = "0.2.60" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "protocol16" +version = "0.1.0" +dependencies = [ + "bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "winapi" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[metadata] +"checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5" +"checksum bytes 0.4.12 (registry+https://github.com/rust-lang/crates.io-index)" = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c" +"checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08" +"checksum libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)" = "d44e80633f007889c7eff624b709ab43c92d708caad982295768a7b13ca3b5eb" +"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a" diff --git a/lib/protocol16/Cargo.toml b/lib/protocol16/Cargo.toml index 46bf86d..4280506 100644 --- a/lib/protocol16/Cargo.toml +++ b/lib/protocol16/Cargo.toml @@ -7,3 +7,4 @@ edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] +bytes = "0.4.12" \ No newline at end of file diff --git a/lib/protocol16/src/lib.rs b/lib/protocol16/src/lib.rs index fb79999..2c80ff9 100644 --- a/lib/protocol16/src/lib.rs +++ b/lib/protocol16/src/lib.rs @@ -1,403 +1,651 @@ -// import io -// import struct +extern crate bytes; -// from collections import namedtuple +use std::collections::HashMap; +use std::io::Cursor; -// from . import type_codes +use bytes::Buf; -// EventData = namedtuple("EventData", ['Code', 'Parameters']) -// OperationResponse = namedtuple("OperationResponse", ['OperationCode', 'ReturnCode', 'DebugMessage', 'Parameters']) -// OperationRequest = namedtuple('OperationRequest', ['OperationCode', 'Parameters']) +mod types; +use std::io::Read; -// def deserialize_byte(byte_stream): -// return struct.unpack("B", byte_stream.read(1))[0] +use types::TypeCode; +use types::Value; +fn deserialize_boolean(buf: &mut Cursor<&[u8]>) -> std::option::Option { + Some(Value::Boolean(buf.get_u8() != 0)) +} -// def deserialize_double(byte_stream): -// return struct.unpack(">d", byte_stream.read(8))[0] +fn deserialize_byte(buf: &mut Cursor<&[u8]>) -> std::option::Option { + Some(Value::Byte(buf.get_u8())) +} -// def deserialize_float(byte_stream): -// return round(struct.unpack(">f", byte_stream.read(4))[0], 2) +fn deserialize_float(buf: &mut Cursor<&[u8]>) -> std::option::Option { + Some(Value::Float(buf.get_f32_be())) +} +fn deserialize_integer(buf: &mut Cursor<&[u8]>) -> std::option::Option { + Some(Value::Integer(buf.get_u32_be())) +} -// def deserialize_integer(byte_stream): -// return struct.unpack(">I", byte_stream.read(4))[0] +fn deserialize_long(buf: &mut Cursor<&[u8]>) -> std::option::Option { + Some(Value::Long(buf.get_i64_be())) +} +fn deserialize_short(buf: &mut Cursor<&[u8]>) -> std::option::Option { + Some(Value::Short(buf.get_i16_be())) +} -// def deserialize_short(byte_stream): -// return struct.unpack(">h", byte_stream.read(2))[0] +fn deserialize_double(buf: &mut Cursor<&[u8]>) -> std::option::Option { + Some(Value::Double(buf.get_f64_be())) +} +fn deserialize_string(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let size = buf.get_i16_be(); + let mut local_buffer = vec![0; size as usize]; -// def deserialize_long(byte_stream): -// return struct.unpack(">q", byte_stream.read(8))[0] + buf.read_exact(&mut local_buffer[..]).unwrap(); + Some(Value::String(String::from_utf8(local_buffer).unwrap())) +} +fn deserialize_string_array(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let size = buf.get_i16_be() as usize; + let mut value = vec![]; -// def deserialize_dictionary(byte_stream): -// key_type_code = deserialize_byte(byte_stream) -// value_type_code = deserialize_byte(byte_stream) -// dict_size = deserialize_short(byte_stream) + for _ in 0..size { + if let Some(v) = deserialize_string(buf) { + match v { + Value::String(s) => { + value.push(s); + } + _ => {} + } + } + } -// result = {} + Some(Value::StringArray(value)) +} -// for _ in range(0, dict_size): -// key = deserialize( -// byte_stream, deserialize_byte(byte_stream) if ( -// key_type_code == 0 or key_type_code == 42) else key_type_code) -// value = deserialize( -// byte_stream, deserialize_byte(byte_stream) if ( -// value_type_code == 0 or value_type_code == 42) else value_type_code) -// result[key] = value +fn deserialize_byte_array(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let size = buf.get_u32_be() as usize; + let mut value = vec![]; -// return result - - -// def deserialize_string(byte_stream): -// size = deserialize_short(byte_stream) -// if not size: -// return "" - -// return byte_stream.read(size).decode('utf-8', errors='replace') - - -// def deserialize_string_array(byte_stream): -// size = deserialize_short(byte_stream) - -// result = [] - -// if not size: -// return result - -// for _ in range(0, size): -// result.append(deserialize_string(byte_stream)) - -// return result - - -// def deserialize_parameter_table(byte_stream): -// size = deserialize_short(byte_stream) - -// result = {} - -// for _ in range(0, size): -// key = deserialize_byte(byte_stream) -// value_type_code = deserialize_byte(byte_stream) -// value = deserialize(byte_stream, value_type_code) - -// result[key] = value - -// return result - - -// def deserialize_event_data(byte_stream): -// code = deserialize_byte(byte_stream) - -// return EventData(code, deserialize_parameter_table(byte_stream)) - - -// def deserialize_integer_array(byte_stream): -// return None - - -// def deserialize_boolean(byte_stream): -// return struct.unpack(">?", byte_stream.read(1))[0] - - -// def deserialize_operation_response(byte_stream): -// operation_code = deserialize_byte(byte_stream) -// return_code = deserialize_short(byte_stream) -// debug_message = deserialize(byte_stream, deserialize_byte(byte_stream)) -// parameters = deserialize_parameter_table(byte_stream) - -// return OperationResponse(operation_code, return_code, debug_message, parameters) - - -// def deserialize_operation_request(byte_stream): -// operation_code = deserialize_byte(byte_stream) -// parameters = deserialize_parameter_table(byte_stream) - -// return OperationRequest(operation_code, parameters) + for _ in 0..size { + value.push(buf.get_u8()); + } + Some(Value::ByteArray(value)) +} // def deserialize_byte_array(byte_stream): // size = deserialize_integer(byte_stream) // if not size: // return [] - // return list(byte_stream.read(size)) +fn deserialize_array(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let size = buf.get_i16_be() as usize; + let mut value = vec![]; -// def deserialize_object_array(byte_stream): -// size = deserialize_short(byte_stream) -// result = [] - -// if not size: -// return result - -// for _ in range(0, size): -// typed_code = deserialize_byte(byte_stream) -// result.append(deserialize(byte_stream, typed_code)) - -// return result + if size == 0 { + return None; + } + let type_code = buf.get_u8(); -// def deserialize_array(byte_stream): -// size = deserialize_short(byte_stream) -// result = [] - -// if not size: -// return result - -// typed_code = deserialize_byte(byte_stream) + for _ in 0..size { + value.push(deserialize(type_code, buf).unwrap()); + } -// if typed_code == type_codes.BYTE_ARRAY: -// return deserialize_byte_array(byte_stream) + Some(Value::Array(value)) +} -// if typed_code == type_codes.STRING_ARRAY: -// return deserialize_string_array(byte_stream) +fn deserialize_dictionary(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let key_type_code = buf.get_u8(); + let value_type_code = buf.get_u8(); + let size = buf.get_i16_be() as usize; -// for _ in range(0, size): -// result.append(deserialize(byte_stream, typed_code)) + if size == 0 { + return None; + } -// return result + let mut value: HashMap = HashMap::new(); + for _ in 0..size { + let key_code = if key_type_code == 0 || key_type_code == 42 { + buf.get_u8() + } else { + key_type_code + }; -// deserializers = { -// 0: lambda _ : None, -// 42: lambda _ : None, -// type_codes.DICTIONARY: deserialize_dictionary, -// type_codes.STRING_ARRAY: deserialize_string_array, -// type_codes.BYTE: deserialize_byte, -// type_codes.DOUBLE: deserialize_double, -// type_codes.EVENT_DATA: deserialize_event_data, -// type_codes.FLOAT: deserialize_float, -// type_codes.INTEGER: deserialize_integer, -// type_codes.SHORT: deserialize_short, -// type_codes.LONG: deserialize_long, -// type_codes.INTEGER_ARRAY: deserialize_integer_array, -// type_codes.BOOLEAN: deserialize_boolean, -// type_codes.OPERATION_RESPONSE: deserialize_operation_response, -// type_codes.OPERATION_REQUEST: deserialize_operation_request, -// type_codes.STRING: deserialize_string, -// type_codes.BYTE_ARRAY: deserialize_byte_array, -// type_codes.ARRAY: deserialize_array, -// type_codes.OBJECT_ARRAY: deserialize_object_array -// } + let key = deserialize(key_code, buf); -// def deserialize(byte_stream, typed_code): -// if typed_code in deserializers: -// return deserializers[typed_code](byte_stream) - -// return None + let value_code = if value_type_code == 0 || value_type_code == 42 { + buf.get_u8() + } else { + value_type_code + }; + let val = deserialize(value_code, buf); + value.insert(format!("{}", key.unwrap()), val.unwrap()); + } + + Some(Value::Dictionary(value)) +} + +fn deserialize_parameter_table(buf: &mut Cursor<&[u8]>) -> HashMap { + let size = buf.get_i16_be() as usize; + + let mut value: HashMap = HashMap::new(); + + for _ in 0..size { + let key_type_code = buf.get_u8(); + let value_type_code = buf.get_u8(); + let val = deserialize(value_type_code, buf); + + value.insert(key_type_code, val.unwrap()); + } + + value +} + +fn deserialize_event_data(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let code = buf.get_u8(); + + Some(Value::EventData(types::EventData { + code, + parameters: deserialize_parameter_table(buf), + })) +} + +fn deserialize_operation_response(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let code = buf.get_u8(); + let return_code = buf.get_i16_be(); + let debug_message = if let Value::String(s) = deserialize(buf.get_u8(), buf).unwrap() { + s + } else { + "None".to_owned() + }; + let parameters = deserialize_parameter_table(buf); + Some(Value::OperationResponse(types::OperationResponse { + code, + return_code, + debug_message, + parameters, + })) +} + +fn deserialize_operation_request(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let code = buf.get_u8(); + + Some(Value::OperationRequest(types::OperationRequest { + code, + parameters: deserialize_parameter_table(buf), + })) +} + +fn deserialize_object_array(buf: &mut Cursor<&[u8]>) -> std::option::Option { + let size = buf.get_i16_be() as usize; + let mut value = vec![]; + + if size == 0 { + return None; + } + + for _ in 0..size { + let type_code = buf.get_u8(); + value.push(deserialize(type_code, buf).unwrap()); + } + + Some(Value::Array(value)) +} + +pub fn deserialize(type_code: u8, buf: &mut Cursor<&[u8]>) -> std::option::Option { + match TypeCode::from(type_code) { + TypeCode::Null => Some(Value::None), + TypeCode::Boolean => deserialize_boolean(buf), + TypeCode::Byte => deserialize_byte(buf), + TypeCode::Double => deserialize_double(buf), + TypeCode::Float => deserialize_float(buf), + TypeCode::Integer => deserialize_integer(buf), + TypeCode::Long => deserialize_long(buf), + TypeCode::Short => deserialize_short(buf), + TypeCode::String => deserialize_string(buf), + TypeCode::StringArray => deserialize_string_array(buf), + TypeCode::ByteArray => deserialize_byte_array(buf), + TypeCode::Array => deserialize_array(buf), + TypeCode::Dictionary => deserialize_dictionary(buf), + TypeCode::OperationRequest => deserialize_operation_request(buf), + TypeCode::OperationResponse => deserialize_operation_response(buf), + TypeCode::EventData => deserialize_event_data(buf), + TypeCode::ObjectArray => deserialize_object_array(buf), + _ => panic!("Unimplemented type code {}", type_code), + } +} #[cfg(test)] -mod tests -{ -// def test_deserialize_dictionary(): -// byte_stream = io.BytesIO(bytes([68, 115, 115, 0, 2, 0, 8, 116, 101, 115, 116, 75, 101, 121, 49, 0, 10, 116, 101, 115, 116, 86, 97, 108, 117, 101, 49, 0, 8, 116, 101, 115, 116, 75, 101, 121, 50, 0, 10, 116, 101, 115, 116, 86, 97, 108, 117, 101, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result["testKey1"] == "testValue1" -// assert result["testKey2"] == "testValue2" - - -// def test_deserialize_string_array(): -// byte_stream = io.BytesIO(bytes([121, 0, 2, 115, 0, 5, 116, 101, 115, 116, 49, 0, 5, 116, 101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result[0] == "test1" -// assert result[1] == "test2" - - -// def test_deserialize_byte(): -// byte_stream = io.BytesIO(bytes([98, 6])) -// typed_code = struct.unpack("B", byte_stream.read(1))[0] - -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result == 6 - - -// def test_deserialize_double(): -// byte_stream = io.BytesIO(bytes([100, 64, 147, 74, 51, 51, 51, 51, 51, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result == 1234.55 - - -// def test_deserialize_event_data(): -// byte_stream = io.BytesIO(bytes([101, 100, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result.Code == 100 -// assert result.Parameters[0] == "test1" -// assert result.Parameters[1] == "test2" - - -// def test_deserialize_float(): -// byte_stream = io.BytesIO(bytes([102, 68, 154, 81, 154, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result == 1234.55 - - -// def test_deserialize_integer(): -// byte_stream = io.BytesIO(bytes([105, 0, 0, 4, 210, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result == 1234 - - -// def test_deserialize_short(): -// byte_stream = io.BytesIO(bytes([107, 4, 210, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result == 1234 - - -// def test_deserialize_long(): -// byte_stream = io.BytesIO(bytes([108, 0, 0, 0, 0, 0, 0, 4, 210, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result == 1234 - - -// def test_deserialize_integer_array(): -// byte_stream = io.BytesIO(bytes([121, 0, 2, 105, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result[0] == 0 -// assert result[1] == 1 - - -// def test_deserialize_boolean(): -// byte_stream = io.BytesIO(bytes([111, 1])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result == True - - -// def test_deserialize_operation_response(): -// byte_stream = io.BytesIO(bytes([112, 100, 0, 100, 42, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result.OperationCode == 100 -// assert result.ReturnCode == 100 -// assert result.Parameters[0] == "test1" -// assert result.Parameters[1] == "test2" - - -// def test_deserialize_operation_request(): -// byte_stream = io.BytesIO(bytes([113, 100, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result.OperationCode == 100 -// assert result.Parameters[0] == "test1" -// assert result.Parameters[1] == "test2" - - -// def test_deserialize_string(): -// byte_stream = io.BytesIO(bytes([115, 0, 12, 116, 101, 115, 116, 95, 109, 101, 115, 115, 97, 103, 101, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result == "test_message" - - -// def test_deserialize_byte_array(): -// byte_stream = io.BytesIO(bytes([120, 0, 0, 0, 2, 6, 7, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result[0] == 6 -// assert result[1] == 7 - - -// def test_deserialize_array_dictionary(): -// byte_stream = io.BytesIO(bytes([121, 0, 1, 68, 105, 115, 0, 1, 0, 0, 0, 0, 0, 5, 116, 101, 115, 116, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result[0][0] == "test1" - - -// def test_deserialize_array_byte_array(): -// byte_stream = io.BytesIO(bytes([121, 0, 1, 120, 0, 0, 0, 4, 0, 2, 4, 8, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result[0] == 0 -// assert result[1] == 2 -// assert result[2] == 4 -// assert result[3] == 8 - - -// def test_deserialize_array_array(): -// byte_stream = io.BytesIO(bytes([121, 0, 1, 121, 0, 3, 105, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result[0][0] == 1 -// assert result[0][1] == 2 -// assert result[0][2] == 3 - - -// def test_deserialize_object_array(): -// byte_stream = io.BytesIO(bytes([122, 0, 2, 115, 0, 5, 116, 101, 115, 116, 49, 115, 0, 5, 116, 101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) - -// typed_code = struct.unpack("B", byte_stream.read(1))[0] -// result = deseliarizer.deserialize(byte_stream, typed_code) - -// assert result -// assert result[0] == "test1" -// assert result[1] == "test2" - - -} \ No newline at end of file +mod tests { + use super::*; + + #[test] + fn deserialize_dictionary() { + let value = vec![ + 68, 115, 115, 0, 2, 0, 8, 116, 101, 115, 116, 75, 101, 121, 49, 0, 10, 116, 101, 115, + 116, 86, 97, 108, 117, 101, 49, 0, 8, 116, 101, 115, 116, 75, 101, 121, 50, 0, 10, 116, + 101, 115, 116, 86, 97, 108, 117, 101, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Dictionary(v) => { + return assert_eq!( + v.get("testKey1"), + Some(&Value::String("testValue1".to_owned())) + ) + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_string_array() { + let value = vec![ + 121, 0, 2, 115, 0, 5, 116, 101, 115, 116, 49, 0, 5, 116, 101, 115, 116, 50, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Array(v) => { + if let Value::String(val) = &v[0] { + assert_eq!(val, &"test1".to_owned()); + } + if let Value::String(val) = &v[1] { + assert_eq!(val, &"test2".to_owned()); + } + return; + } + Value::StringArray(v) => { + return assert_eq!(vec!["test1".to_owned(), "test2".to_owned()], v) + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn test_deserialize_byte() { + let value = vec![98, 6]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Byte(v) => return assert_eq!(v, 6), + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_double() { + let value = vec![100, 64, 147, 74, 51, 51, 51, 51, 51, 0, 0, 0, 0, 0, 0, 0]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Double(v) => return assert_eq!(v, 1234.55), + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + // typed_code = struct.unpack("B", byte_stream.read(1))[0] + // result = deseliarizer.deserialize(byte_stream, typed_code) + + // assert result + // assert result == 1234.55 + + #[test] + fn deserialize_event_data() { + let value = vec![ + 101, 100, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116, + 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::EventData(v) => { + assert_eq!(v.code, 100); + assert_eq!( + v.parameters.get(&0).unwrap(), + &Value::String("test1".to_owned()) + ); + return; + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_float() { + let value = vec![102, 68, 154, 81, 154, 0, 0, 0]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Float(v) => return assert_eq!(v, 1234.55), + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_integer() { + let value = vec![105, 0, 0, 4, 210, 0, 0, 0]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Integer(v) => return assert_eq!(v, 1234), + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_short() { + let value = vec![107, 4, 210, 0]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Short(v) => return assert_eq!(v, 1234), + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_long() { + let value = vec![108, 0, 0, 0, 0, 0, 0, 4, 210, 0, 0, 0, 0, 0, 0, 0]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Long(v) => return assert_eq!(v, 1234), + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_integer_array() { + let value = vec![121, 0, 2, 105, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Array(v) => { + if let Value::Integer(val) = v[0] { + assert_eq!(val, 0); + } + if let Value::Integer(val) = v[1] { + assert_eq!(val, 1); + } + return; + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + // typed_code = struct.unpack("B", byte_stream.read(1))[0] + // result = deseliarizer.deserialize(byte_stream, typed_code) + + // assert result + // assert result[0] == 0 + // assert result[1] == 1 + + #[test] + fn deserialize_boolean() { + let value = vec![111, 1]; + let mut buf = Cursor::new(&value[..]); + + let type_code = buf.get_u8(); + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Boolean(v) => return assert_eq!(v, true), + _ => assert!(false), + } + } + assert!(false); + } + #[test] + fn deserialize_operation_response() { + let value = vec![ + 112, 100, 0, 100, 42, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, + 101, 115, 116, 50, 0, 0, 0, 0, 0, 0, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::OperationResponse(v) => { + assert_eq!(v.code, 100); + assert_eq!(v.return_code, 100); + assert_eq!( + v.parameters.get(&1).unwrap(), + &Value::String("test2".to_owned()) + ); + return; + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_operation_request() { + let value = vec![ + 113, 100, 0, 2, 0, 115, 0, 5, 116, 101, 115, 116, 49, 1, 115, 0, 5, 116, 101, 115, 116, + 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::OperationRequest(v) => { + assert_eq!(v.code, 100); + assert_eq!( + v.parameters.get(&1).unwrap(), + &Value::String("test2".to_owned()) + ); + return; + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_string() { + let value = vec![ + 115, 0, 12, 116, 101, 115, 116, 95, 109, 101, 115, 115, 97, 103, 101, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::String(v) => return assert_eq!(&v, "test_message"), + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_byte_array() { + let value = vec![120, 0, 0, 0, 2, 6, 7, 0]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::ByteArray(v) => { + assert_eq!(&v[0], &6); + assert_eq!(&v[1], &7); + return; + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_array_dictionary() { + let value = vec![ + 121, 0, 1, 68, 105, 115, 0, 1, 0, 0, 0, 0, 0, 5, 116, 101, 115, 116, 49, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Array(v) => { + if let Value::Dictionary(val) = &v[0] { + assert_eq!(val.get("0").unwrap(), &Value::String("test1".to_owned())); + } + return; + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_array_byte_array() { + let value = vec![121, 0, 1, 120, 0, 0, 0, 4, 0, 2, 4, 8, 0, 0, 0, 0]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Array(v) => { + if let Value::ByteArray(val) = &v[0] { + assert_eq!(val[0], 0); + assert_eq!(val[1], 2); + assert_eq!(val[2], 4); + assert_eq!(val[3], 8); + return; + } + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_array_array() { + let value = vec![ + 121, 0, 1, 121, 0, 3, 105, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Array(v) => { + if let Value::Integer(val) = &v[0][0] { + assert_eq!(val, &1); + } + if let Value::Integer(val) = &v[0][1] { + assert_eq!(val, &2); + } + if let Value::Integer(val) = &v[0][2] { + assert_eq!(val, &3); + } + return; + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } + + #[test] + fn deserialize_object_array() { + let value = vec![ + 122, 0, 2, 115, 0, 5, 116, 101, 115, 116, 49, 115, 0, 5, 116, 101, 115, 116, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ]; + let mut buf = Cursor::new(&value[..]); + let type_code = buf.get_u8(); + + let result = deserialize(type_code, &mut buf); + if let Some(value) = result { + match value { + Value::Array(v) => { + if let Value::String(val) = &v[0] { + assert_eq!(val, &"test1".to_owned()); + } + if let Value::String(val) = &v[1] { + assert_eq!(val, &"test2".to_owned()); + } + return; + } + _ => assert!(false), + } + } + panic!("Unimplemented!") + } +} diff --git a/lib/protocol16/src/type_codes.rs b/lib/protocol16/src/type_codes.rs deleted file mode 100644 index 39e8ead..0000000 --- a/lib/protocol16/src/type_codes.rs +++ /dev/null @@ -1,19 +0,0 @@ -pub enum TypeCode { - Dictionary = 68, - StringArray = 97, - Byte = 98, - Double = 100, - EventData = 101, - Float = 102, - Integer = 105, - Short = 107, - Long = 108, - BooleanArray = 110, - Boolean = 111, - OperationResponse = 112, - OperationRequest = 113, - String = 115, - ByteArray = 120, - Array = 121, - ObjectArray = 122 -} \ No newline at end of file diff --git a/lib/protocol16/src/types.rs b/lib/protocol16/src/types.rs new file mode 100644 index 0000000..252f7cf --- /dev/null +++ b/lib/protocol16/src/types.rs @@ -0,0 +1,115 @@ +use std::collections::HashMap; + +pub enum TypeCode { + Unknown = 0, + Null = 42, + Dictionary = 68, + StringArray = 97, + Byte = 98, + Double = 100, + EventData = 101, + Float = 102, + Integer = 105, + Short = 107, + Long = 108, + BooleanArray = 110, + Boolean = 111, + OperationResponse = 112, + OperationRequest = 113, + String = 115, + ByteArray = 120, + Array = 121, + ObjectArray = 122, +} + +impl From for TypeCode { + fn from(v: u8) -> Self { + match v { + 0 => TypeCode::Unknown, + 42 => TypeCode::Null, + 68 => TypeCode::Dictionary, + 97 => TypeCode::StringArray, + 98 => TypeCode::Byte, + 100 => TypeCode::Double, + 101 => TypeCode::EventData, + 102 => TypeCode::Float, + 105 => TypeCode::Integer, + 107 => TypeCode::Short, + 108 => TypeCode::Long, + 110 => TypeCode::BooleanArray, + 111 => TypeCode::Boolean, + 112 => TypeCode::OperationResponse, + 113 => TypeCode::OperationRequest, + 115 => TypeCode::String, + 120 => TypeCode::ByteArray, + 121 => TypeCode::Array, + 122 => TypeCode::ObjectArray, + _ => TypeCode::Unknown + } + } +} + +#[derive(Clone, Debug, PartialEq)] +pub struct EventData { + pub code: u8, + pub parameters: HashMap +} + +#[derive(Clone, Debug, PartialEq)] +pub struct OperationResponse { + pub code: u8, + pub return_code: i16, + pub debug_message: String, + pub parameters: HashMap +} + +#[derive(Clone, Debug, PartialEq)] +pub struct OperationRequest { + pub code: u8, + pub parameters: HashMap +} + + +#[derive(Clone, Debug, PartialEq)] +pub enum Value { + None, + Dictionary(HashMap), + StringArray(Vec), + Byte(u8), + Double(f64), + EventData(EventData), + Float(f32), + Integer(u32), + Short(i16), + Long(i64), + BooleanArray(Vec), + Boolean(bool), + OperationResponse(OperationResponse), + OperationRequest(OperationRequest), + String(String), + ByteArray(Vec), + Array(Vec), + ObjectArray(Vec) +} + +impl std::ops::Index for Value { + type Output = Value; + + fn index(&self, index: usize) -> &Self::Output { + match self { + Value::Array(v) => &v[index], + _ => panic!("Non indexable type") + } + } +} + +impl std::fmt::Display for Value { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Value::String(v) => write!(f, "{}", v), + Value::Byte(v) => write!(f, "{}", v), + Value::Integer(v) => write!(f, "{}", v), + v => write!(f, "{:?}", v) + } + } +}