diff --git a/ipc/codegen/src/codegen.rs b/ipc/codegen/src/codegen.rs index e9d80c7e9..89bd9548c 100644 --- a/ipc/codegen/src/codegen.rs +++ b/ipc/codegen/src/codegen.rs @@ -66,6 +66,12 @@ pub fn expand_ipc_implementation( push(Annotatable::Item(interface_map.item)); } +macro_rules! literal { + ($builder:ident, $($arg:tt)*) => { + $builder.expr().lit().str::<&str>(&format!($($arg)*)) + } +} + fn field_name(builder: &aster::AstBuilder, arg: &Arg) -> ast::Ident { match arg.pat.node { PatKind::Ident(_, ref ident, _) => builder.id(ident.node), @@ -247,9 +253,15 @@ fn implement_dispatch_arm_invoke( ) -> P { let deserialize_expr = if buffer { - quote_expr!(cx, ::ipc::binary::deserialize(buf).expect("ipc deserialization error, aborting")) + quote_expr!(cx, + ::ipc::binary::deserialize(buf) + .unwrap_or_else(|e| { panic!("ipc error while deserializing payload, aborting \n payload: {:?}, \n error: {:?}", buf, e); } ) + ) } else { - quote_expr!(cx, ::ipc::binary::deserialize_from(r).expect("ipc deserialization error, aborting")) + quote_expr!(cx, + ::ipc::binary::deserialize_from(r) + .unwrap_or_else(|e| { panic!("ipc error while deserializing payload, aborting \n error: {:?}", e); } ) + ) }; let invoke_serialize_stmt = implement_dispatch_arm_invoke_stmt(cx, builder, dispatch); @@ -273,10 +285,9 @@ fn implement_dispatch_arm( { let index_ident = builder.id(format!("{}", index + (RESERVED_MESSAGE_IDS as u32)).as_str()); let invoke_expr = implement_dispatch_arm_invoke(cx, builder, dispatch, buffer); - let dispatching_trace = "Dispatching: ".to_owned() + &dispatch.function_name; - let dispatching_trace_literal = builder.expr().lit().str::<&str>(&dispatching_trace); + let trace = literal!(builder, "Dispatching: {}", &dispatch.function_name); quote_arm!(cx, $index_ident => { - trace!(target: "ipc", $dispatching_trace_literal); + trace!(target: "ipc", $trace); $invoke_expr }) } @@ -425,22 +436,20 @@ fn implement_client_method_body( request_serialization_statements }; - let invocation_trace = "Invoking: ".to_owned() + &dispatch.function_name; - let invocation_trace_literal = builder.expr().lit().str::<&str>(&invocation_trace); - + let trace = literal!(builder, "Invoking: {}", &dispatch.function_name); if let Some(ref return_ty) = dispatch.return_type_ty { let return_expr = quote_expr!(cx, ::ipc::binary::deserialize_from::<$return_ty, _>(&mut *socket).unwrap() ); quote_expr!(cx, { - trace!(target: "ipc", $invocation_trace_literal); - $request + trace!(target: "ipc", $trace); + $request; $return_expr }) } else { quote_expr!(cx, { - trace!(target: "ipc", $invocation_trace_literal); + trace!(target: "ipc", $trace); $request }) } @@ -557,7 +566,6 @@ fn push_client( push_with_socket_client_implementation(cx, builder, interface_map, push); } - fn push_with_socket_client_implementation( cx: &ExtCtxt, builder: &aster::AstBuilder, @@ -694,7 +702,6 @@ fn implement_handshake_arm( ) } - fn get_str_from_lit(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Result { match lit.node { ast::LitKind::Str(ref s, _) => Ok(format!("{}", s)), @@ -825,7 +832,7 @@ fn implement_interface( _ => { cx.span_err( item.span, - "`#[derive(Ipc)]` may only be applied to item implementations"); + "`#[derive(Ipc)]` may only be applied to implementations and traits"); return Err(Error); }, }; diff --git a/ipc/rpc/src/binary.rs b/ipc/rpc/src/binary.rs index 3ef2785d6..4cc091456 100644 --- a/ipc/rpc/src/binary.rs +++ b/ipc/rpc/src/binary.rs @@ -288,6 +288,9 @@ impl BinaryConvertable for BTreeMap where K : BinaryConvertable + Or let key = if key_size == 0 { try!(K::from_empty_bytes()) } else { + if index + key_size > buffer.len() { + return Err(BinaryConvertError::boundaries()) + } try!(K::from_bytes(&buffer[index..index+key_size], length_stack)) }; index = index + key_size; @@ -299,6 +302,9 @@ impl BinaryConvertable for BTreeMap where K : BinaryConvertable + Or let val = if val_size == 0 { try!(V::from_empty_bytes()) } else { + if index + val_size > buffer.len() { + return Err(BinaryConvertError::boundaries()) + } try!(V::from_bytes(&buffer[index..index+val_size], length_stack)) }; result.insert(key, val); @@ -365,13 +371,16 @@ impl BinaryConvertable for VecDeque where T: BinaryConvertable { try!(T::from_empty_bytes()) } else { + if index + next_size > buffer.len() { + return Err(BinaryConvertError::boundaries()) + } try!(T::from_bytes(&buffer[index..index+next_size], length_stack)) }; result.push_back(item); index = index + next_size; if index == buffer.len() { break; } - if index + next_size > buffer.len() { + if index > buffer.len() { return Err(BinaryConvertError::boundaries()) } } @@ -388,8 +397,6 @@ impl BinaryConvertable for VecDeque where T: BinaryConvertable { } } -// - impl BinaryConvertable for Vec where T: BinaryConvertable { fn size(&self) -> usize { match T::len_params() { @@ -433,13 +440,16 @@ impl BinaryConvertable for Vec where T: BinaryConvertable { try!(T::from_empty_bytes()) } else { + if index + next_size > buffer.len() { + return Err(BinaryConvertError::boundaries()) + } try!(T::from_bytes(&buffer[index..index+next_size], length_stack)) }; result.push(item); index = index + next_size; if index == buffer.len() { break; } - if index + next_size > buffer.len() { + if index > buffer.len() { return Err(BinaryConvertError::boundaries()) } } @@ -1151,3 +1161,17 @@ fn serialize_not_enough_lengths() { other => panic!("Not an missing length param error but: {:?}", other), } } + +#[test] +fn vec_of_vecs() { + let sample = vec![vec![5u8, 10u8], vec![], vec![9u8, 11u8]]; + let serialized = serialize(&sample).unwrap(); + let deserialized = deserialize::>>(&serialized).unwrap(); + assert_eq!(sample, deserialized); + + // empty + let sample: Vec> = vec![]; + let serialized = serialize(&sample).unwrap(); + let deserialized = deserialize::>>(&serialized).unwrap(); + assert_eq!(sample, deserialized); +} diff --git a/ipc/tests/binary.rs.in b/ipc/tests/binary.rs.in index b9b263f66..e6297e67f 100644 --- a/ipc/tests/binary.rs.in +++ b/ipc/tests/binary.rs.in @@ -18,6 +18,7 @@ use ipc::*; use std::mem; use std::collections::VecDeque; +use util::Bytes; #[derive(Binary)] pub enum Root { @@ -49,6 +50,11 @@ pub struct TwoVec { v2: Vec, } +#[derive(Binary)] +struct ChunkSet { + items: Vec, +} + #[test] fn opt_two_vec() { let example: Option = None; @@ -64,3 +70,100 @@ fn enum_with_struct() { let deserialized = ::ipc::binary::deserialize::(&serialized).unwrap(); assert_eq!(example, deserialized); } + +#[test] +fn chunks() { + let sample: Vec = vec! [ + 15, 0, 0, 0, 0, 0, 0, 0, 81, 6, 0, 0, 0, 0, 0, 0, + 110, 0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, 0, 0, + 112, 0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, 0, 0, + 173, 0, 0, 0, 0, 0, 0, 0, 103, 0, 0, 0, 0, 0, 0, 0, + 112, 0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, 0, 0, + 107, 0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, 0, 0, + 114, 0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, 0, 0, + 114, 0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, 0, 0, + 81, 6, 0, 0, 0, 0, 0, 0, + + 248, 108, 58, 133, 4, 168, 23, 200, 0, 130, 82, 8, 148, 182, 54, + 177, 224, 198, 163, 123, 250, 122, 157, 158, 75, 138, 30, 7, 83, 91, 141, 56, 46, 136, 2, + 197, 12, 243, 220, 69, 192, 0, 128, 28, 160, 32, 232, 123, 221, 90, 116, 93, 94, 136, 78, + 235, 200, 167, 154, 3, 175, 74, 53, 133, 32, 239, 199, 169, 46, 95, 111, 114, 204, 19, 138, + 15, 167, 160, 103, 72, 60, 241, 165, 248, 130, 213, 45, 166, 249, 102, 83, 87, 98, 153, + 68, 58, 13, 83, 193, 182, 217, 182, 9, 241, 217, 28, 162, 152, 114, 136, 248, 110, 130, 6, + 96, 133, 4, 168, 23, 200, 0, 131, 1, 95, 144, 148, 100, 131, 212, 219, 190, 174, 5, 47, + 105, 201, 11, 11, 210, 108, 207, 242, 164, 74, 218, 19, 135, 6, 10, 36, 24, 30, 64, 0, + 128, 27, 160, 206, 145, 163, 186, 24, 122, 126, 115, 80, 203, 152, 219, 160, 243, 1, 139, + 109, 199, 115, 50, 159, 197, 95, 184, 174, 53, 150, 3, 200, 82, 138, 22, 160, 119, 226, + 202, 208, 136, 165, 174, 240, 216, 222, 27, 214, 12, 213, 250, 68, 214, 144, 120, 53, 158, + 46, 124, 105, 87, 220, 213, 192, 28, 81, 118, 6, 248, 110, 130, 6, 95, 133, 4, 168, 23, + 200, 0, 131, 1, 95, 144, 148, 100, 131, 212, 219, 190, 174, 5, 47, 105, 201, 11, 11, 210, + 108, 207, 242, 164, 74, 218, 19, 135, 6, 10, 36, 24, 30, 64, 0, 128, 27, 160, 19, 172, 66, + 208, 28, 189, 213, 239, 125, 170, 127, 147, 190, 97, 171, 194, 229, 241, 178, 176, 111, + 3, 201, 217, 9, 179, 23, 159, 159, 64, 55, 225, 160, 7, 123, 227, 76, 149, 80, 48, 130, + 122, 23, 165, 175, 24, 89, 228, 128, 25, 106, 160, 195, 82, 204, 206, 150, 83, 70, 127, + 34, 221, 169, 80, 43, 248, 110, 130, 6, 102, 133, 4, 168, 23, 200, 0, 131, 1, 95, 144, 148, + 100, 131, 212, 219, 190, 174, 5, 47, 105, 201, 11, 11, 210, 108, 207, 242, 164, 74, 218, + 19, 135, 6, 10, 36, 24, 30, 64, 0, 128, 27, 160, 29, 6, 237, 5, 67, 42, 51, 65, 172, 133, + 9, 222, 160, 39, 202, 88, 230, 123, 232, 135, 234, 5, 244, 215, 99, 129, 242, 59, 63, 36, + 26, 253, 160, 104, 178, 37, 227, 142, 255, 186, 41, 91, 108, 206, 13, 108, 24, 73, 229, + 96, 224, 142, 230, 93, 214, 27, 60, 119, 149, 119, 56, 62, 5, 204, 179, 248, 171, 129, 136, + 133, 4, 168, 23, 200, 0, 131, 2, 77, 248, 148, 137, 32, 90, 58, 59, 42, 105, 222, 109, 191, + 127, 1, 237, 19, 178, 16, 139, 44, 67, 231, 128, 184, 68, 169, 5, 156, 187, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 105, 4, 134, 47, 167, 212, 79, 177, 44, 91, 97, 85, 184, 182, 222, 59, 231, 242, + 110, 141, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2, 28, 160, 98, 5, 133, 180, 19, 27, 159, 186, 76, 27, 159, 143, 186, 97, 124, 253, 123, 40, + 87, 35, 184, 115, 99, 176, 68, 85, 191, 210, 218, 132, 220, 52, 160, 48, 160, 79, 26, 47, 127, 253, + 55, 252, 196, 196, 129, 87, 131, 132, 84, 74, 166, 33, 85, 134, 25, 34, 244, 14, 1, 16, 1, 205, 34, + 30, 3, 248, 101, 3, 133, 13, 43, 184, 47, 225, 131, 1, 95, 144, 148, 202, 110, 19, 32, 65, 111, 158, + 204, 235, 91, 252, 213, 35, 215, 54, 91, 165, 67, 183, 171, 1, 128, 28, 160, 182, 194, 27, 223, 136, + 182, 189, 146, 57, 61, 173, 62, 58, 241, 42, 80, 125, 174, 84, 191, 82, 124, 228, 62, 216, 233, 116, + 117, 227, 207, 138, 56, 160, 31, 210, 242, 212, 31, 156, 129, 155, 166, 64, 102, 140, 134, 35, 176, + 137, 201, 206, 213, 199, 238, 132, 185, 145, 220, 217, 151, 80, 243, 93, 71, 211, 248, 110, 130, + 6, 101, 133, 4, 168, 23, 200, 0, 131, 1, 95, 144, 148, 100, 131, 212, 219, 190, 174, 5, 47, 105, + 201, 11, 11, 210, 108, 207, 242, 164, 74, 218, 19, 135, 6, 10, 36, 24, 30, 64, 0, 128, 27, 160, + 86, 37, 61, 45, 13, 251, 9, 19, 188, 242, 233, 83, 77, 137, 28, 185, 141, 105, 217, 54, 182, 156, + 119, 223, 213, 112, 240, 20, 119, 167, 4, 7, 160, 95, 53, 122, 159, 6, 209, 70, 155, 122, 153, 165, + 192, 249, 223, 219, 83, 159, 40, 242, 39, 44, 132, 182, 208, 232, 77, 64, 178, 241, 233, 230, 253, + 248, 110, 130, 6, 99, 133, 4, 168, 23, 200, 0, 131, 1, 95, 144, 148, 100, 131, 212, 219, 190, 174, + 5, 47, 105, 201, 11, 11, 210, 108, 207, 242, 164, 74, 218, 19, 135, 6, 10, 36, 24, 30, 64, 0, 128, + 27, 160, 114, 33, 104, 64, 195, 12, 156, 235, 56, 59, 210, 102, 183, 210, 216, 137, 223, 207, 134, + 63, 65, 36, 204, 121, 38, 175, 214, 106, 184, 197, 26, 173, 160, 39, 94, 238, 34, 106, 190, 22, + 225, 95, 211, 192, 249, 95, 231, 1, 111, 8, 204, 133, 35, 84, 242, 134, 75, 61, 50, 26, 150, 46, + 209, 129, 155, 248, 105, 106, 133, 5, 103, 130, 1, 225, 131, 2, 130, 119, 148, 191, 78, 215, 178, + 127, 29, 102, 101, 70, 227, 13, 116, 213, 13, 23, 61, 32, 188, 167, 84, 128, 132, 60, 207, 214, + 11, 28, 160, 3, 83, 228, 182, 32, 30, 183, 26, 157, 247, 32, 142, 60, 192, 100, 175, 106, 216, + 144, 16, 100, 165, 95, 91, 135, 138, 14, 41, 82, 251, 207, 159, 160, 74, 160, 161, 187, 63, 216, + 18, 23, 64, 172, 216, 238, 192, 134, 191, 204, 206, 236, 197, 134, 116, 130, 15, 85, 113, 173, + 130, 39, 50, 160, 49, 222, 248, 110, 130, 6, 98, 133, 4, 168, 23, 200, 0, 131, 1, 95, 144, 148, + 100, 131, 212, 219, 190, 174, 5, 47, 105, 201, 11, 11, 210, 108, 207, 242, 164, 74, 218, 19, 135, + 6, 10, 36, 24, 30, 64, 0, 128, 28, 160, 138, 12, 20, 188, 112, 66, 91, 30, 216, 44, 24, 124, 242, + 200, 111, 179, 32, 26, 37, 221, 239, 110, 1, 84, 48, 89, 86, 61, 169, 129, 90, 21, 160, 44, 172, + 112, 11, 130, 45, 247, 188, 207, 91, 247, 195, 58, 188, 110, 127, 59, 227, 41, 151, 244, 41, 120, + 68, 185, 238, 41, 236, 195, 141, 38, 16, 248, 112, 131, 5, 238, 44, 133, 4, 168, 23, 200, 0, 131, + 1, 95, 144, 148, 5, 113, 9, 145, 204, 89, 103, 32, 126, 46, 182, 84, 47, 76, 28, 159, 77, 184, + 154, 59, 136, 1, 100, 240, 147, 154, 69, 101, 18, 128, 27, 160, 130, 0, 124, 82, 177, 112, 241, + 14, 47, 186, 67, 117, 176, 187, 147, 94, 4, 177, 218, 198, 55, 59, 245, 9, 142, 95, 88, 220, 63, + 98, 175, 49, 160, 17, 204, 228, 24, 242, 38, 166, 219, 17, 56, 103, 244, 33, 125, 223, 45, 43, + 252, 215, 163, 40, 1, 187, 152, 34, 229, 82, 180, 213, 148, 129, 32, 248, 110, 130, 6, 100, 133, + 4, 168, 23, 200, 0, 131, 1, 95, 144, 148, 100, 131, 212, 219, 190, 174, 5, 47, 105, 201, 11, 11, + 210, 108, 207, 242, 164, 74, 218, 19, 135, 6, 10, 36, 24, 30, 64, 0, 128, 27, 160, 149, 149, 154, + 6, 198, 127, 14, 11, 164, 0, 244, 4, 74, 83, 9, 108, 164, 66, 186, 26, 109, 69, 98, 41, 149, 33, + 238, 137, 23, 175, 124, 226, 160, 39, 249, 210, 237, 52, 83, 110, 229, 138, 84, 199, 64, 19, 209, + 156, 195, 9, 50, 184, 64, 78, 67, 158, 167, 121, 220, 80, 137, 104, 240, 50, 60, 248, 112, 131, 5, + 238, 45, 133, 4, 168, 23, 200, 0, 131, 1, 95, 144, 148, 247, 0, 201, 156, 113, 12, 158, 3, 208, 61, + 221, 91, 236, 235, 235, 195, 40, 46, 100, 73, 136, 13, 230, 68, 67, 114, 161, 197, 100, 128, 27, + 160, 123, 206, 0, 221, 2, 87, 197, 156, 109, 157, 133, 31, 26, 145, 223, 150, 235, 160, 54, 144, + 210, 146, 31, 173, 221, 128, 233, 148, 73, 82, 191, 220, 160, 57, 62, 114, 94, 77, 8, 116, 150, + 51, 112, 241, 70, 149, 157, 209, 193, 213, 109, 248, 102, 177, 27, 132, 226, 77, 141, 128, 122, + 185, 238, 188, 114, 248, 110, 130, 6, 97, 133, 4, 168, 23, 200, 0, 131, 1, 95, 144, 148, 100, + 131, 212, 219, 190, 174, 5, 47, 105, 201, 11, 11, 210, 108, 207, 242, 164, 74, 218, 19, 135, 6, + 10, 36, 24, 30, 64, 0, 128, 28, 160, 53, 222, 41, 101, 73, 44, 103, 26, 39, 165, 120, 194, 128, + 67, 109, 151, 96, 42, 193, 47, 255, 23, 27, 247, 8, 125, 200, 53, 129, 69, 103, 64, 160, 49, 12, + 64, 143, 74, 149, 161, 245, 68, 83, 89, 101, 212, 254, 81, 16, 170, 176, 33, 87, 6, 112, 34, 153, + 6, 192, 98, 126, 188, 17, 199, 155]; + + let chunks = ::ipc::binary::deserialize::(&sample).unwrap(); + let total_length = chunks.items.iter().fold(0usize, |total, item| total + item.len()); + + assert_eq!(1617, total_length); +}