Copying inappropriately aligned buffer in ipc reader

arrow-array/src/array/list_array.rs

@@ -861,16 +861,40 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "memory is not aligned")]
+    #[should_panic(expected = "Need at least 8 bytes in buffers[0]")]
     fn test_primitive_array_alignment() {
-        let ptr = arrow_buffer::alloc::allocate_aligned(8);
+        let ptr = arrow_buffer::alloc::allocate_aligned_zeroed(8);
         let buf = unsafe { Buffer::from_raw_parts(ptr, 8, 8) };
+        let buf1 = buf.slice(1);
         let buf2 = buf.slice(1);
+
+        // Aligned
+        let array_data = ArrayData::builder(DataType::Int32)
+            .add_buffer(buf)
+            .len(2)
+            .build()
+            .unwrap();
+        let array = Int32Array::from(array_data);
+        assert_eq!(array.len(), 2);
+        assert_eq!(array.value(0), 0);
+        assert_eq!(array.value(1), 0);
+
+        // Not aligned.
+        // `ArrayData::build` checks buffer length.
         let array_data = ArrayData::builder(DataType::Int32)
+            .add_buffer(buf1)
+            .len(1)
+            .build()
+            .unwrap();
+        let array = Int32Array::from(array_data);
+        assert_eq!(array.len(), 1);
+        assert_eq!(array.value(0), 0);
+
+        ArrayData::builder(DataType::Int32)
             .add_buffer(buf2)
+            .len(2)
             .build()
             .unwrap();
-        drop(Int32Array::from(array_data));
     }
 
     #[test]

arrow-array/src/array/primitive_array.rs

@@ -840,7 +840,7 @@ impl<T: ArrowPrimitiveType> From<ArrayData> for PrimitiveArray<T> {
             data,
             // SAFETY:
             // ArrayData must be valid, and validated data type above
-            raw_values: unsafe { RawPtrBox::new(ptr) },
+            raw_values: unsafe { RawPtrBox::unchecked_new(ptr) },
         }
     }
 }

arrow-array/src/raw_pointer.rs

@@ -45,6 +45,21 @@ impl<T> RawPtrBox<T> {
         Self { ptr: ptr.cast() }
     }
 
+    /// # Safety
+    /// The user must guarantee that:
+    /// * the contents where `ptr` points to are never `moved`. This is guaranteed when they are Pinned.
+    /// * the lifetime of this struct does not outlive the lifetime of `ptr`.
+    /// Failure to fulfill any the above conditions results in undefined behavior.
+    /// # Panic
+    /// This function panics if:
+    /// * `ptr` is null
+    ///
+    /// Unlike `new`, this function does not check if `ptr` is aligned to a slice of type `T`.
+    pub(crate) unsafe fn unchecked_new(ptr: *const u8) -> Self {
+        let ptr = NonNull::new(ptr as *mut u8).expect("Pointer cannot be null");
+        Self { ptr: ptr.cast() }
+    }
+
     pub(super) fn as_ptr(&self) -> *const T {
         self.ptr.as_ptr()
     }