| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License.. |
| |
| use sgx_alloc::alignbox::*; |
| use sgx_types::*; |
| use std::mem; |
| |
| impl_struct! { |
| pub struct user_struct { |
| pub a: u8, |
| pub b: [u16; 2], |
| pub c: u32, |
| pub d: [u64; 6], |
| } |
| } |
| |
| impl_struct! { |
| pub struct struct_align_128_t { |
| pub key: sgx_key_128bit_t, |
| } |
| } |
| |
| impl_struct! { |
| pub struct struct_no_align_t { |
| pub key1: sgx_key_128bit_t, |
| pub key2: sgx_key_128bit_t, |
| pub key3: sgx_key_128bit_t, |
| pub key4: sgx_key_128bit_t, |
| } |
| } |
| |
| impl_struct! { |
| #[derive(PartialEq, Debug)] |
| pub struct struct_align_t{ |
| pub key1: sgx_key_128bit_t, |
| pub pad1: [u8; 16], |
| pub key2: sgx_key_128bit_t , |
| pub pad2: [u8; 16], |
| pub key3: sgx_key_128bit_t, |
| pub pad3: [u8; 16], |
| pub key4: sgx_key_128bit_t, |
| } |
| } |
| |
| pub fn test_alignbox() { |
| //align |
| { |
| let aligned_box: Option<AlignBox<struct_align_128_t>> = |
| AlignBox::<struct_align_128_t>::new(); |
| assert!(aligned_box.is_some()); |
| } |
| //no align |
| { |
| let str_slice: &[AlignReq] = &[]; |
| let aligned_box: Option<AlignBox<user_struct>> = |
| AlignBox::<user_struct>::new_with_req(1, &str_slice); |
| assert!(aligned_box.is_none()); |
| } |
| //align |
| { |
| let str_slice: &[AlignReq] = &[ |
| AlignReq { |
| offset: offset_of!(user_struct, a), |
| len: mem::size_of::<u8>(), |
| }, |
| AlignReq { |
| offset: offset_of!(user_struct, b), |
| len: mem::size_of::<[u16; 2]>(), |
| }, |
| AlignReq { |
| offset: offset_of!(user_struct, d), |
| len: mem::size_of::<[u64; 6]>(), |
| }, |
| ]; |
| let aligned_box: Option<AlignBox<user_struct>> = |
| AlignBox::<user_struct>::new_with_req(1, &str_slice); |
| assert!(aligned_box.is_some()); |
| } |
| //no align |
| { |
| let str_slice: &[AlignReq] = &[ |
| AlignReq { |
| offset: offset_of!(user_struct, a), |
| len: mem::size_of::<u8>(), |
| }, |
| AlignReq { |
| offset: offset_of!(user_struct, b), |
| len: mem::size_of::<[u16; 2]>(), |
| }, |
| AlignReq { |
| offset: offset_of!(user_struct, d), |
| len: mem::size_of::<[u64; 6]>(), |
| }, |
| ]; |
| let aligned_box: Option<AlignBox<user_struct>> = |
| AlignBox::<user_struct>::new_with_req(16, &str_slice); |
| assert!(aligned_box.is_none()); |
| } |
| //no align |
| { |
| let str_slice: &[AlignReq] = &[ |
| AlignReq { |
| offset: offset_of!(struct_align_t, key1), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key2), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key3), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key4), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| ]; |
| let aligned_box: Option<AlignBox<struct_align_t>> = |
| AlignBox::<struct_align_t>::new_with_req(32, &str_slice); |
| assert!(aligned_box.is_none()); |
| } |
| //align |
| { |
| let str_slice: &[AlignReq] = &[ |
| AlignReq { |
| offset: offset_of!(struct_align_t, key1), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key2), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key3), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key4), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| ]; |
| let aligned_box: Option<AlignBox<struct_align_t>> = |
| AlignBox::<struct_align_t>::new_with_req(16, &str_slice); |
| assert!(aligned_box.is_some()); |
| } |
| } |
| |
| pub fn test_alignbox_heap_init() { |
| let str_slice: &[AlignReq] = &[ |
| AlignReq { |
| offset: offset_of!(struct_align_t, key1), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key2), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key3), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key4), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| ]; |
| |
| let stack_align_obj = struct_align_t { |
| key1: [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ], |
| pad1: [0x00; 16], |
| key2: [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ], |
| pad2: [0x00; 16], |
| key3: [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ], |
| pad3: [0x00; 16], |
| key4: [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ], |
| }; |
| let heap_align_obj = AlignBox::<struct_align_t>::heap_init_with_req( |
| |mut t| { |
| t.key1 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad1 = [0x00; 16]; |
| t.key2 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad2 = [0x00; 16]; |
| t.key3 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad3 = [0x00; 16]; |
| t.key4 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| }, |
| 16, |
| &str_slice, |
| ); |
| assert!(heap_align_obj.is_some()); |
| assert_eq!(stack_align_obj, *(heap_align_obj.unwrap())); |
| } |
| |
| pub fn test_alignbox_clone() { |
| let str_slice: &[AlignReq] = &[ |
| AlignReq { |
| offset: offset_of!(struct_align_t, key1), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key2), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key3), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key4), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| ]; |
| let heap_align_obj = AlignBox::<struct_align_t>::heap_init_with_req( |
| |mut t| { |
| t.key1 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad1 = [0x00; 16]; |
| t.key2 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad2 = [0x00; 16]; |
| t.key3 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad3 = [0x00; 16]; |
| t.key4 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| }, |
| 16, |
| &str_slice, |
| ); |
| assert!(heap_align_obj.is_some()); |
| let align_box_clone = heap_align_obj.clone(); |
| assert_eq!(*align_box_clone.unwrap(), *heap_align_obj.unwrap()); |
| } |
| |
| pub fn test_alignbox_clonefrom() { |
| let str_slice: &[AlignReq] = &[ |
| AlignReq { |
| offset: offset_of!(struct_align_t, key1), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key2), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key3), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key4), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| ]; |
| let heap_align_obj = AlignBox::<struct_align_t>::heap_init_with_req( |
| |mut t| { |
| t.key1 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad1 = [0x00; 16]; |
| t.key2 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad2 = [0x00; 16]; |
| t.key3 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad3 = [0x00; 16]; |
| t.key4 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| }, |
| 16, |
| &str_slice, |
| ); |
| assert!(heap_align_obj.is_some()); |
| |
| let mut heap_align_zero_obj = AlignBox::<struct_align_t>::new_with_req(16, &str_slice); |
| assert!(heap_align_zero_obj.is_some()); |
| heap_align_zero_obj.clone_from(&heap_align_obj); |
| assert_eq!(*(heap_align_zero_obj.unwrap()), *(heap_align_obj.unwrap())); |
| } |
| |
| pub fn test_alignbox_clonefrom_no_eq_size() { |
| let str_slice: &[AlignReq] = &[ |
| AlignReq { |
| offset: offset_of!(struct_align_t, key1), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key2), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key3), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| AlignReq { |
| offset: offset_of!(struct_align_t, key4), |
| len: mem::size_of::<sgx_key_128bit_t>(), |
| }, |
| ]; |
| let heap_align_obj = AlignBox::<struct_align_t>::heap_init_with_req( |
| |mut t| { |
| t.key1 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad1 = [0x00; 16]; |
| t.key2 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad2 = [0x00; 16]; |
| t.key3 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| t.pad3 = [0x00; 16]; |
| t.key4 = [ |
| 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, |
| 0xfe, 0xff, |
| ]; |
| }, |
| 16, |
| &str_slice, |
| ); |
| assert!(heap_align_obj.is_some()); |
| |
| let mut heap_align_zero_obj = AlignBox::<struct_align_t>::new_with_req(1, &str_slice); |
| assert!(heap_align_zero_obj.is_some()); |
| heap_align_zero_obj.clone_from(&heap_align_obj); |
| assert_eq!(*(heap_align_zero_obj.unwrap()), *(heap_align_obj.unwrap())); |
| } |