nix_compat/nar/reader/async/mod.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
use std::{
mem::MaybeUninit,
pin::Pin,
task::{self, Poll},
};
use tokio::io::{self, AsyncBufRead, AsyncRead, ErrorKind::InvalidData};
// Required reading for understanding this module.
use crate::{
nar::{self, wire::PadPar},
wire::{self, BytesReader},
};
mod read;
#[cfg(test)]
mod test;
pub type Reader<'a> = dyn AsyncBufRead + Unpin + Send + 'a;
/// Start reading a NAR file from `reader`.
pub async fn open<'a, 'r>(reader: &'a mut Reader<'r>) -> io::Result<Node<'a, 'r>> {
read::token(reader, &nar::wire::TOK_NAR).await?;
Node::new(reader).await
}
pub enum Node<'a, 'r: 'a> {
Symlink {
target: Vec<u8>,
},
File {
executable: bool,
reader: FileReader<'a, 'r>,
},
Directory(DirReader<'a, 'r>),
}
impl<'a, 'r: 'a> Node<'a, 'r> {
/// Start reading a [Node], matching the next [wire::Node].
///
/// Reading the terminating [wire::TOK_PAR] is done immediately for [Node::Symlink],
/// but is otherwise left to [DirReader] or [BytesReader].
async fn new(reader: &'a mut Reader<'r>) -> io::Result<Self> {
Ok(match read::tag(reader).await? {
nar::wire::Node::Sym => {
let target = wire::read_bytes(reader, 1..=nar::wire::MAX_TARGET_LEN).await?;
if target.contains(&0) {
return Err(InvalidData.into());
}
read::token(reader, &nar::wire::TOK_PAR).await?;
Node::Symlink { target }
}
tag @ (nar::wire::Node::Reg | nar::wire::Node::Exe) => Node::File {
executable: tag == nar::wire::Node::Exe,
reader: FileReader {
inner: BytesReader::new_internal(reader, ..).await?,
},
},
nar::wire::Node::Dir => Node::Directory(DirReader::new(reader)),
})
}
}
/// File contents, readable through the [AsyncRead] trait.
///
/// It comes with some caveats:
/// * You must always read the entire file, unless you intend to abandon the entire archive reader.
/// * You must abandon the entire archive reader upon the first error.
///
/// It's fine to read exactly `reader.len()` bytes without ever seeing an explicit EOF.
pub struct FileReader<'a, 'r> {
inner: BytesReader<&'a mut Reader<'r>, PadPar>,
}
impl FileReader<'_, '_> {
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn len(&self) -> u64 {
self.inner.len()
}
}
impl AsyncRead for FileReader<'_, '_> {
fn poll_read(
self: Pin<&mut Self>,
cx: &mut task::Context,
buf: &mut io::ReadBuf,
) -> Poll<io::Result<()>> {
Pin::new(&mut self.get_mut().inner).poll_read(cx, buf)
}
}
impl AsyncBufRead for FileReader<'_, '_> {
fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut task::Context) -> Poll<io::Result<&[u8]>> {
Pin::new(&mut self.get_mut().inner).poll_fill_buf(cx)
}
fn consume(self: Pin<&mut Self>, amt: usize) {
Pin::new(&mut self.get_mut().inner).consume(amt)
}
}
/// A directory iterator, yielding a sequence of [Node]s.
/// It must be fully consumed before reading further from the [DirReader] that produced it, if any.
pub struct DirReader<'a, 'r> {
reader: &'a mut Reader<'r>,
/// Previous directory entry name.
/// We have to hang onto this to enforce name monotonicity.
prev_name: Vec<u8>,
}
pub struct Entry<'a, 'r> {
pub name: &'a [u8],
pub node: Node<'a, 'r>,
}
impl<'a, 'r> DirReader<'a, 'r> {
fn new(reader: &'a mut Reader<'r>) -> Self {
Self {
reader,
prev_name: vec![],
}
}
/// Read the next [Entry] from the directory.
///
/// We explicitly don't implement [Iterator], since treating this as
/// a regular Rust iterator will surely lead you astray.
///
/// * You must always consume the entire iterator, unless you abandon the entire archive reader.
/// * You must abandon the entire archive reader on the first error.
/// * You must abandon the directory reader upon the first [None].
/// * Even if you know the amount of elements up front, you must keep reading until you encounter [None].
pub async fn next(&mut self) -> io::Result<Option<Entry<'_, 'r>>> {
// COME FROM the previous iteration: if we've already read an entry,
// read its terminating TOK_PAR here.
if !self.prev_name.is_empty() {
read::token(self.reader, &nar::wire::TOK_PAR).await?;
}
if let nar::wire::Entry::None = read::tag(self.reader).await? {
return Ok(None);
}
let mut name = [MaybeUninit::uninit(); nar::wire::MAX_NAME_LEN + 1];
let name =
wire::read_bytes_buf(self.reader, &mut name, 1..=nar::wire::MAX_NAME_LEN).await?;
if name.contains(&0) || name.contains(&b'/') || name == b"." || name == b".." {
return Err(InvalidData.into());
}
// Enforce strict monotonicity of directory entry names.
if &self.prev_name[..] >= name {
return Err(InvalidData.into());
}
self.prev_name.clear();
self.prev_name.extend_from_slice(name);
read::token(self.reader, &nar::wire::TOK_NOD).await?;
Ok(Some(Entry {
name: &self.prev_name,
node: Node::new(self.reader).await?,
}))
}
}