Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 34 additions & 0 deletions .github/workflows/i686.yml
Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
name: 32 bit

on:
pull_request:
branches: ["main"]

env:
CARGO_TERM_COLOR: always

jobs:
build:
runs-on: ubuntu-latest

steps:
- uses: actions/checkout@v7

# Install Just to run CI scripts
- uses: extractions/setup-just@v4

- name: Install 32-bit linker dependencies
run: |
sudo apt-get update
sudo apt-get install -y gcc-multilib

- name: Install Rust toolchain
uses: dtolnay/rust-toolchain@stable
with:
targets: i686-unknown-linux-gnu

- name: Build
run: cargo build --release --target i686-unknown-linux-gnu

- name: Run tests
run: cargo test --target i686-unknown-linux-gnu
164 changes: 131 additions & 33 deletions src/header.rs
Original file line number Diff line number Diff line change
Expand Up @@ -15,17 +15,21 @@ pub struct Header {

impl Encode for Header {
fn encode<B: BufMut>(&self, buf: &mut B) -> Result<()> {
match self.size.map(|size| size + 8) {
Some(size) if size > u32::MAX as usize => {
1u32.encode(buf)?;
self.kind.encode(buf)?;
let too_large = || Error::TooLarge(self.kind);

// Have to include the size of this extra field
((size + 8) as u64).encode(buf)
}
match self.size {
Some(size) => {
(size as u32).encode(buf)?;
self.kind.encode(buf)
if size > u32::MAX as usize - 8 {
1u32.encode(buf)?;
self.kind.encode(buf)?;

// Have to include the size of this extra field
let size = size.checked_add(16).ok_or_else(too_large)?;
u64::try_from(size).map_err(|_| too_large())?.encode(buf)
} else {
(size as u32 + 8).encode(buf)?;
self.kind.encode(buf)
}
}
None => {
0u32.encode(buf)?;
Expand All @@ -42,12 +46,9 @@ impl Decode for Header {

let size = match size {
0 => None,
1 => {
// Read another 8 bytes
let size = u64::decode(buf)?;
Some(size.checked_sub(16).ok_or(Error::InvalidSize)? as usize)
}
_ => Some(size.checked_sub(8).ok_or(Error::InvalidSize)? as usize),
// The real size follows in another 8 bytes.
1 => Some(body_size(kind, u64::decode(buf)?, 16)?),
_ => Some(body_size(kind, size.into(), 8)?),
};

Ok(Self { kind, size })
Expand Down Expand Up @@ -77,34 +78,36 @@ impl ReadFrom for Header {

impl ReadFrom for Option<Header> {
fn read_from<R: Read + ?Sized>(r: &mut R) -> Result<Self> {
let mut buf = [0u8; 8];
let n = r.read(&mut buf)?;
let mut buf = [0u8; 16];
let n = r.read(&mut buf[..8])?;
if n == 0 {
return Ok(None);
}

r.read_exact(&mut buf[n..])?;
r.read_exact(&mut buf[n..8])?;

let size = u32::from_be_bytes(buf[0..4].try_into().unwrap());
let kind = u32::from_be_bytes(buf[4..8].try_into().unwrap()).into();
// A size of 1 means the real size follows in another 8 bytes.
let len = header_len(&buf);
r.read_exact(&mut buf[8..len])?;

let size = match size {
0 => None,
1 => {
// Read another 8 bytes
r.read_exact(&mut buf)?;
let size = u64::from_be_bytes(buf);
let size = size.checked_sub(16).ok_or(Error::InvalidSize)?;

Some(size as usize)
}
_ => Some(size.checked_sub(8).ok_or(Error::InvalidSize)? as usize),
};
Header::decode(&mut &buf[..len]).map(Some)
}
}

Ok(Some(Header { kind, size }))
/// The length of a header, given its first 8 bytes.
pub(crate) fn header_len(buf: &[u8]) -> usize {
match buf[0..4] {
[0, 0, 0, 1] => 16,
_ => 8,
}
}

/// Convert the size of an atom, as stored in its header, into the size of its body.
fn body_size(kind: FourCC, size: u64, header_len: u64) -> Result<usize> {
let size = size.checked_sub(header_len).ok_or(Error::InvalidSize)?;
usize::try_from(size).map_err(|_| Error::TooLarge(kind))
}

// Utility methods
impl Header {
pub(crate) fn read_body<R: Read + ?Sized>(&self, r: &mut R) -> Result<Cursor<Vec<u8>>> {
Expand Down Expand Up @@ -161,3 +164,98 @@ impl Header {
Ok(Cursor::new(buf))
}
}

#[cfg(test)]
mod tests {
use super::*;

const KIND: FourCC = FourCC::new(b"free");

#[test]
fn body_size_subtracts_header() {
assert_eq!(body_size(KIND, 8, 8).unwrap(), 0);
assert_eq!(body_size(KIND, 24, 16).unwrap(), 8);
assert!(matches!(body_size(KIND, 7, 8), Err(Error::InvalidSize)));
assert!(matches!(body_size(KIND, 15, 16), Err(Error::InvalidSize)));
}

#[test]
#[cfg(target_pointer_width = "32")]
fn body_size_rejects_usize_overflow() {
let size = u32::MAX as u64 + 17;
assert!(matches!(
body_size(KIND, size, 16),
Err(Error::TooLarge(KIND))
));
}

#[test]
fn decode_large_size() {
let mut buf: &[u8] = &[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 24];
let header = Header::decode(&mut buf).unwrap();
assert_eq!(header.size, Some(8));

let mut buf: &[u8] = &[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 15];
assert!(matches!(Header::decode(&mut buf), Err(Error::InvalidSize)));
}

#[test]
fn read_from_matches_decode() {
let cases: &[&[u8]] = &[
&[0, 0, 0, 0, b'f', b'r', b'e', b'e'],
&[0, 0, 0, 16, b'f', b'r', b'e', b'e'],
&[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 24],
];

for case in cases {
let decoded = Header::decode(&mut &case[..]).unwrap();
let read = <Header as ReadFrom>::read_from(&mut &case[..]).unwrap();
assert_eq!(decoded.kind, read.kind);
assert_eq!(decoded.size, read.size);
}

let empty: &[u8] = &[];
assert!(<Option<Header> as ReadFrom>::read_from(&mut &empty[..])
.unwrap()
.is_none());
}

#[test]
fn encode_size_boundary() {
for size in [0, u32::MAX as usize - 8] {
let header = Header {
kind: KIND,
size: Some(size),
};
let mut buf = Vec::new();
header.encode(&mut buf).unwrap();
assert_eq!(Header::decode(&mut &buf[..]).unwrap().size, Some(size));
}
}

#[test]
#[cfg(target_pointer_width = "32")]
fn encode_rejects_overflow() {
let header = Header {
kind: KIND,
size: Some((u32::MAX - 7) as usize),
};
assert!(matches!(
header.encode(&mut Vec::new()),
Err(Error::TooLarge(KIND))
));
}

#[test]
#[cfg(target_pointer_width = "64")]
fn encode_rejects_overflow() {
let header = Header {
kind: KIND,
size: Some(usize::MAX - 15),
};
assert!(matches!(
header.encode(&mut Vec::new()),
Err(Error::TooLarge(KIND))
));
}
}
58 changes: 40 additions & 18 deletions src/tokio/header.rs
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
use crate::{Error, Header, Result};
use crate::{header::header_len, Decode, Error, Header, Result};

use super::*;

Expand All @@ -14,30 +14,52 @@ impl AsyncReadFrom for Header {

impl AsyncReadFrom for Option<Header> {
async fn read_from<R: AsyncRead + Unpin + ?Sized>(r: &mut R) -> Result<Self> {
let mut buf = [0u8; 8];
let n = r.read(&mut buf).await?;
let mut buf = [0u8; 16];
let n = r.read(&mut buf[..8]).await?;
if n == 0 {
return Ok(None);
}

r.read_exact(&mut buf[n..]).await?;
r.read_exact(&mut buf[n..8]).await?;

let size = u32::from_be_bytes(buf[0..4].try_into().unwrap());
let kind = u32::from_be_bytes(buf[4..8].try_into().unwrap()).into();
// A size of 1 means the real size follows in another 8 bytes.
let len = header_len(&buf);
r.read_exact(&mut buf[8..len]).await?;

let size = match size {
0 => None,
1 => {
// Read another 8 bytes
r.read_exact(&mut buf).await?;
let size = u64::from_be_bytes(buf);
let size = size.checked_sub(16).ok_or(Error::InvalidSize)?;
Header::decode(&mut &buf[..len]).map(Some)
}
}

#[cfg(test)]
mod tests {
use super::*;

use std::{future::Future, pin::pin, task::*};

// Reading from a slice never blocks, so a single poll completes the future.
fn read(mut buf: &[u8]) -> Result<Option<Header>> {
let fut = pin!(<Option<Header> as AsyncReadFrom>::read_from(&mut buf));
match fut.poll(&mut Context::from_waker(Waker::noop())) {
Poll::Ready(res) => res,
Poll::Pending => unreachable!(),
}
}

#[test]
fn read_from() {
assert!(read(&[]).unwrap().is_none());

let header = read(&[0, 0, 0, 16, b'f', b'r', b'e', b'e'])
.unwrap()
.unwrap();
assert_eq!(header.size, Some(8));

Some(size as usize)
}
_ => Some(size.checked_sub(8).ok_or(Error::InvalidSize)? as usize),
};
let header = read(&[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 24])
.unwrap()
.unwrap();
assert_eq!(header.size, Some(8));

Ok(Some(Header { kind, size }))
let res = read(&[0, 0, 0, 1, b'f', b'r', b'e', b'e', 0, 0, 0, 0, 0, 0, 0, 15]);
assert!(matches!(res, Err(Error::InvalidSize)));
}
}
Loading