zip.rs

//! ZIP の読み書き
//!
//! docx、xlsx、pptx はどれも中身が ZIP である。ここはその外側を扱う。
//!
//! # 圧縮したまま写せること
//!
//! 開いたファイルを一部だけ直して保存するとき、触っていないパートは
//! [`Writer::copy`] で圧縮済みのバイト列のまま写す。展開も圧縮もしないので速く、
//! グラフや画像のように folio が中身を知らないパートも、そのまま残る。
//!
//! # 大きなパートを順に読むこと
//!
//! [`Archive::reader`] は展開を別のスレッドに任せ、出来たぶんから順に渡す。
//! 展開しきったものをメモリに置かないので、数 GB のシートでも読める。
//! 読む側と展開する側が同時に進むので、待ち時間も減る。
//!
//! # 大きなパートを順に書くこと
//!
//! [`Writer::start`] で始めたエントリは、長さが決まる前に書き始める。
//! 8MB までは手元にためて、収まればふつうのヘッダを書く。
//! 超えたときだけ ZIP64 のヘッダにして、長さは書き終えてから埋める。

use crate::crc::{Crc, checksum};
use crate::deflate::Deflate;
use crate::error::Error;
use crate::inflate;
use std::collections::HashMap;
use std::fs::File;
use std::io::{BufWriter, Read, Seek, SeekFrom, Write};
use std::path::Path;
use std::sync::mpsc::{Receiver, sync_channel};
use std::time::{SystemTime, UNIX_EPOCH};


/// 縮めていない
pub const STORED: u16 = 0;

/// deflate で縮めてある
pub const DEFLATED: u16 = 8;

/// これを超えたら 32 ビットに収まらない
const LIMIT: u64 = 0xffffffff;

/// 長さが決まる前に書き出す判断をする境目
const HOLD_LIMIT: usize = 8 * 1024 * 1024;

/// 末尾から中央目録の在り処を探す範囲。追記コメントの上限 65535 に少し足したもの
const TAIL: u64 = 66 * 1024;

/// 一度に受け渡すバイト数
const PIECE: usize = 256 * 1024;


/// 中央目録に載っている 1 エントリ
#[derive(Debug, Clone)]
pub struct Entry {
    /// パートの名前
    pub name: String,
    /// STORED か DEFLATED
    pub method: u16,
    /// 中身の CRC-32
    pub crc: u32,
    /// 縮めたあとの長さ
    pub compressed: u64,
    /// 縮める前の長さ
    pub uncompressed: u64,
    /// ローカルヘッダの位置
    pub offset: u64,
}


/// 読むために開いた ZIP
pub struct Archive {
    file: File,
    entry: Vec<Entry>,
    place: HashMap<String, usize>,
}


impl Archive {
    /// ファイルを開いて中央目録を読む
    pub fn open(path: &Path) -> Result<Archive, Error> {
        let mut file = File::open(path)?;
        let size = file.seek(SeekFrom::End(0))?;
        let tail = TAIL.min(size);
        file.seek(SeekFrom::Start(size - tail))?;
        let mut region = vec![0u8; tail as usize];
        file.read_exact(&mut region)?;

        let end = find_end(&region)?;
        let mut count = u16(&region, end + 10)? as u64;
        let mut length = u32(&region, end + 12)? as u64;
        let mut start = u32(&region, end + 16)? as u64;

        // ZIP64 なら、目録の位置と数は別の記録に入っている
        if count == 0xffff || length == LIMIT || start == LIMIT {
            let locator = find_locator(&region, end)?;
            let position = u64_at(&region, locator + 8)?;
            let mut record = [0u8; 56];
            file.seek(SeekFrom::Start(position))?;
            file.read_exact(&mut record)?;

            if u32(&record, 0)? != 0x06064b50 {
                return Err(Error::new("ZIP64 の中央目録の印が見つかりません"));
            }

            count = u64_at(&record, 32)?;
            length = u64_at(&record, 40)?;
            start = u64_at(&record, 48)?;
        }

        file.seek(SeekFrom::Start(start))?;
        let mut region = vec![0u8; length as usize];
        file.read_exact(&mut region)?;

        let mut entry = Vec::with_capacity(count as usize);
        let mut place = HashMap::with_capacity(count as usize);
        let mut cursor = 0;

        while cursor + 46 <= region.len() {
            if u32(&region, cursor)? != 0x02014b50 {
                break;
            }

            let one = read_entry(&region, cursor)?;
            let name_length = u16(&region, cursor + 28)? as usize;
            let extra_length = u16(&region, cursor + 30)? as usize;
            let comment_length = u16(&region, cursor + 32)? as usize;
            place.insert(one.name.clone(), entry.len());
            entry.push(one);
            cursor += 46 + name_length + extra_length + comment_length;
        }

        Ok(Archive {file, entry, place})
    }

    /// 入っているエントリ
    pub fn entry(&self) -> &[Entry] {
        &self.entry
    }

    /// その名前のパートがあるか
    pub fn has(&self, name: &str) -> bool {
        self.place.contains_key(name)
    }

    /// 縮めたままのバイト列を取り出す
    pub fn raw(&mut self, name: &str) -> Result<Vec<u8>, Error> {
        let index = self.find(name)?;
        let start = self.data_offset(index)?;
        let length = self.entry[index].compressed as usize;
        let mut data = vec![0u8; length];
        self.file.seek(SeekFrom::Start(start))?;
        self.file.read_exact(&mut data).map_err(|error| Error::at(error.to_string(), name))?;
        Ok(data)
    }

    /// 中身を展開して全部返す
    pub fn read(&mut self, name: &str) -> Result<Vec<u8>, Error> {
        let index = self.find(name)?;
        let method = self.entry[index].method;
        let size = self.entry[index].uncompressed as usize;
        let expect = self.entry[index].crc;
        let data = self.raw(name)?;

        let plain = match method {
            STORED => data,
            DEFLATED => inflate::inflate_sized(&data, size).map_err(|error| error.within(name))?,
            _ => return Err(Error::at("知らない圧縮の方式です", name)),
        };

        if checksum(&plain) != expect {
            return Err(Error::at("中身が壊れています", name));
        }

        Ok(plain)
    }

    /// 中身を順に受け取る。展開は別のスレッドが進める
    ///
    /// 縮めたバイトもまとめては読まない。ファイルから少しずつ渡すので、
    /// 縮めて数百 MB あるパートでも、手元に置くのは読みかけのぶんだけになる。
    pub fn reader(&mut self, name: &str) -> Result<Reader, Error> {
        let index = self.find(name)?;
        let method = self.entry[index].method;
        let crc = self.entry[index].crc;
        let length = self.entry[index].compressed;
        let start = self.data_offset(index)?;
        let mut file = self.file.try_clone()?;
        file.seek(SeekFrom::Start(start))?;

        match method {
            STORED => Ok(Reader {
                origin: Origin::File(file, length, Crc::new(), crc, name.to_string()),
            }),

            DEFLATED => Ok(Reader {
                origin: Origin::Thread(spawn(file, length, crc, name.to_string())),
            }),

            _ => Err(Error::at("知らない圧縮の方式です", name)),
        }
    }

    /// 名前からエントリの番号を引く
    fn find(&self, name: &str) -> Result<usize, Error> {
        match self.place.get(name) {
            Some(index) => Ok(*index),
            None => Err(Error::at("パートが見つかりません", name)),
        }
    }

    /// ローカルヘッダを読んで、中身が始まる位置を求める
    fn data_offset(&mut self, index: usize) -> Result<u64, Error> {
        let offset = self.entry[index].offset;
        let mut header = [0u8; 30];
        self.file.seek(SeekFrom::Start(offset))?;
        self.file.read_exact(&mut header)?;

        if u32(&header, 0)? != 0x04034b50 {
            return Err(Error::at("ローカルヘッダの印が見つかりません", &self.entry[index].name));
        }

        let name_length = u16(&header, 26)? as u64;
        let extra_length = u16(&header, 28)? as u64;
        Ok(offset + 30 + name_length + extra_length)
    }
}


/// 中身を順に受け取るもの
pub struct Reader {
    origin: Origin,
}


/// どこから受け取るか
enum Origin {
    /// すでに手元にあるバイト列を、そのまま切って渡す
    Plain(Vec<u8>, usize),
    /// 縮めていないので、ファイルから読んでそのまま渡す
    File(File, u64, Crc, u32, String),
    /// 別のスレッドが展開しながら送ってくる
    Thread(Receiver<Result<Vec<u8>, Error>>),
}


impl Reader {
    /// そろっているバイト列を、順に受け取る形にして返す
    ///
    /// 小さなパートは展開しきってからこちらに載せる。読む側は大きなパートと同じ書き方でよい。
    pub fn plain(data: Vec<u8>) -> Reader {
        Reader {origin: Origin::Plain(data, 0)}
    }

    /// 続きを受け取る。終わったら None
    pub fn next(&mut self) -> Result<Option<Vec<u8>>, Error> {
        match &mut self.origin {
            Origin::Plain(data, sent) => {
                if *sent >= data.len() {
                    return Ok(None);
                }

                let stop = (*sent + PIECE).min(data.len());
                let piece = data[*sent..stop].to_vec();
                *sent = stop;
                Ok(Some(piece))
            }

            Origin::File(file, rest, crc, expect, name) => {
                if *rest == 0 {
                    if crc.finish() != *expect {
                        return Err(Error::at("中身が壊れています", name.as_str()));
                    }

                    return Ok(None);
                }

                let take = (*rest as usize).min(PIECE);
                let mut piece = vec![0u8; take];
                file.read_exact(&mut piece)?;
                crc.update(&piece);
                *rest -= take as u64;
                Ok(Some(piece))
            }

            Origin::Thread(receiver) => match receiver.recv() {
                Ok(Ok(piece)) => Ok(Some(piece)),
                Ok(Err(error)) => Err(error),
                Err(_) => Ok(None),
            },
        }
    }
}


/// 展開する側のスレッドを立てる
///
/// 展開は読む側と同時に進む。待ち行列は少しだけ持ち、読む側が遅ければそこで止まる。
fn spawn(mut file: File, mut rest: u64, expect: u32, name: String) -> Receiver<Result<Vec<u8>, Error>> {
    let (sender, receiver) = sync_channel(4);

    std::thread::spawn(move || {
        let carry = sender.clone();
        let mut crc = Crc::new();

        let mut supply = move || -> Result<Option<Vec<u8>>, Error> {
            if rest == 0 {
                return Ok(None);
            }

            let take = (rest as usize).min(PIECE);
            let mut piece = vec![0u8; take];
            file.read_exact(&mut piece)?;
            rest -= take as u64;
            Ok(Some(piece))
        };

        let mut result = inflate::inflate_stream(&mut supply, &mut |part| {
            crc.update(part);

            match sender.send(Ok(part.to_vec())) {
                Ok(()) => Ok(()),
                Err(_) => Err(Error::new("読む側がいなくなりました")),
            }
        });

        if result.is_ok() && crc.finish() != expect {
            result = Err(Error::new("中身が壊れています"));
        }

        if let Err(error) = result {
            let _ = carry.send(Err(error.within(&name)));
        }
    });

    receiver
}


/// 書き出しの控え
struct Written {
    name: String,
    method: u16,
    crc: u32,
    compressed: u64,
    uncompressed: u64,
    offset: u64,
    time: u16,
    date: u16,
}


/// 書きかけのエントリ
struct Open {
    name: String,
    offset: u64,
    time: u16,
    date: u16,
    /// ヘッダを書き終えたか。まだなら長さが決まっていない
    started: bool,
    /// ヘッダを書くまで手元にためる圧縮済みバイト
    hold: Vec<u8>,
    crc: Crc,
    compressed: u64,
    uncompressed: u64,
    state: Deflate,
}


/// 書くために開いた ZIP
pub struct Writer {
    file: BufWriter<File>,
    position: u64,
    written: Vec<Written>,
    open: Option<Open>,
}


impl Writer {
    /// 新しいファイルを作る
    pub fn create(path: &Path) -> Result<Writer, Error> {
        let file = File::create(path)?;

        Ok(Writer {
            file: BufWriter::new(file),
            position: 0,
            written: Vec::new(),
            open: None,
        })
    }

    /// 縮めて 1 つ書く
    pub fn add(&mut self, name: &str, data: &[u8]) -> Result<(), Error> {
        let packed = crate::deflate::deflate(data);

        // 縮めても短くならないものは、そのまま入れる
        if packed.len() >= data.len() {
            return self.add_stored(name, data);
        }

        self.put(name, DEFLATED, checksum(data), &packed, data.len() as u64)
    }

    /// 縮めずに 1 つ書く
    pub fn add_stored(&mut self, name: &str, data: &[u8]) -> Result<(), Error> {
        self.put(name, STORED, checksum(data), data, data.len() as u64)
    }

    /// 別の ZIP から、縮めたまま写す
    pub fn copy(&mut self, source: &mut Archive, name: &str) -> Result<(), Error> {
        let index = source.find(name)?;
        let method = source.entry[index].method;
        let crc = source.entry[index].crc;
        let uncompressed = source.entry[index].uncompressed;
        let data = source.raw(name)?;
        self.put(name, method, crc, &data, uncompressed)
    }

    /// 長さの決まっていないエントリを書き始める
    pub fn start(&mut self, name: &str) -> Result<(), Error> {
        if self.open.is_some() {
            return Err(Error::at("前のエントリを閉じていません", name));
        }

        let (time, date) = now();

        self.open = Some(Open {
            name: name.to_string(),
            offset: self.position,
            time,
            date,
            started: false,
            hold: Vec::with_capacity(HOLD_LIMIT / 8),
            crc: Crc::new(),
            compressed: 0,
            uncompressed: 0,
            state: Deflate::new(),
        });

        Ok(())
    }

    /// 書き始めたエントリに続きを渡す
    pub fn write(&mut self, data: &[u8]) -> Result<(), Error> {
        let Some(open) = self.open.as_mut() else {
            return Err(Error::new("書き始めていないエントリに書こうとしています"));
        };

        open.crc.update(data);
        open.uncompressed += data.len() as u64;
        open.state.write(data);
        let piece = open.state.take();
        open.hold.extend_from_slice(&piece);

        if !open.started && open.hold.len() >= HOLD_LIMIT {
            let header = local_header(&open.name, DEFLATED, 0, 0, 0, open.time, open.date, true);
            open.started = true;
            let hold = std::mem::take(&mut open.hold);
            open.compressed += hold.len() as u64;
            self.emit(&header)?;
            self.emit(&hold)?;
            return Ok(());
        }

        if open.started {
            let hold = std::mem::take(&mut open.hold);
            open.compressed += hold.len() as u64;
            self.emit(&hold)?;
        }

        Ok(())
    }

    /// 書き始めたエントリを閉じる
    pub fn close(&mut self) -> Result<(), Error> {
        let Some(mut open) = self.open.take() else {
            return Err(Error::new("書き始めていないエントリを閉じようとしています"));
        };

        open.state.finish();
        let piece = open.state.take();
        open.hold.extend_from_slice(&piece);
        let crc = open.crc.finish();

        if !open.started {
            // 8MB に収まったので、ふつうのヘッダを長さ入りで書く
            let compressed = open.hold.len() as u64;
            let header = local_header(
                &open.name,
                DEFLATED,
                crc,
                compressed,
                open.uncompressed,
                open.time,
                open.date,
                false,
            );

            let hold = std::mem::take(&mut open.hold);
            self.emit(&header)?;
            self.emit(&hold)?;

            self.written.push(Written {
                name: open.name,
                method: DEFLATED,
                crc,
                compressed,
                uncompressed: open.uncompressed,
                offset: open.offset,
                time: open.time,
                date: open.date,
            });

            return Ok(());
        }

        let hold = std::mem::take(&mut open.hold);
        open.compressed += hold.len() as u64;
        self.emit(&hold)?;

        // ZIP64 のヘッダを書いてあるので、決まった長さをそこへ埋める
        let name_length = open.name.len() as u64;
        self.patch(open.offset + 14, &crc.to_le_bytes())?;
        self.patch(open.offset + 30 + name_length + 4, &open.uncompressed.to_le_bytes())?;
        self.patch(open.offset + 30 + name_length + 12, &open.compressed.to_le_bytes())?;

        self.written.push(Written {
            name: open.name,
            method: DEFLATED,
            crc,
            compressed: open.compressed,
            uncompressed: open.uncompressed,
            offset: open.offset,
            time: open.time,
            date: open.date,
        });

        Ok(())
    }

    /// 中央目録を書いて閉じる
    pub fn finish(mut self) -> Result<(), Error> {
        if self.open.is_some() {
            return Err(Error::new("閉じていないエントリがあります"));
        }

        let start = self.position;
        let mut region = Vec::new();

        for one in &self.written {
            central_header(&mut region, one);
        }

        self.emit(&region)?;
        let length = region.len() as u64;
        let count = self.written.len() as u64;
        let mut tail = Vec::new();

        if count >= 0xffff || length >= LIMIT || start >= LIMIT {
            let record = self.position;
            tail.extend_from_slice(&0x06064b50u32.to_le_bytes());
            tail.extend_from_slice(&44u64.to_le_bytes());
            tail.extend_from_slice(&45u16.to_le_bytes());
            tail.extend_from_slice(&45u16.to_le_bytes());
            tail.extend_from_slice(&0u32.to_le_bytes());
            tail.extend_from_slice(&0u32.to_le_bytes());
            tail.extend_from_slice(&count.to_le_bytes());
            tail.extend_from_slice(&count.to_le_bytes());
            tail.extend_from_slice(&length.to_le_bytes());
            tail.extend_from_slice(&start.to_le_bytes());

            tail.extend_from_slice(&0x07064b50u32.to_le_bytes());
            tail.extend_from_slice(&0u32.to_le_bytes());
            tail.extend_from_slice(&record.to_le_bytes());
            tail.extend_from_slice(&1u32.to_le_bytes());
        }

        tail.extend_from_slice(&0x06054b50u32.to_le_bytes());
        tail.extend_from_slice(&0u16.to_le_bytes());
        tail.extend_from_slice(&0u16.to_le_bytes());
        tail.extend_from_slice(&(count.min(0xffff) as u16).to_le_bytes());
        tail.extend_from_slice(&(count.min(0xffff) as u16).to_le_bytes());
        tail.extend_from_slice(&(length.min(LIMIT) as u32).to_le_bytes());
        tail.extend_from_slice(&(start.min(LIMIT) as u32).to_le_bytes());
        tail.extend_from_slice(&0u16.to_le_bytes());

        self.emit(&tail)?;
        self.file.flush()?;
        Ok(())
    }

    /// 長さの決まっているエントリを 1 つ書く
    fn put(
        &mut self,
        name: &str,
        method: u16,
        crc: u32,
        data: &[u8],
        uncompressed: u64,
    ) -> Result<(), Error> {
        if self.open.is_some() {
            return Err(Error::at("前のエントリを閉じていません", name));
        }

        let (time, date) = now();
        let offset = self.position;
        let compressed = data.len() as u64;
        let big = compressed >= LIMIT || uncompressed >= LIMIT;
        let header = local_header(name, method, crc, compressed, uncompressed, time, date, big);
        self.emit(&header)?;
        self.emit(data)?;

        self.written.push(Written {
            name: name.to_string(),
            method,
            crc,
            compressed,
            uncompressed,
            offset,
            time,
            date,
        });

        Ok(())
    }

    /// バイト列を書いて、位置を進める
    fn emit(&mut self, data: &[u8]) -> Result<(), Error> {
        self.file.write_all(data)?;
        self.position += data.len() as u64;
        Ok(())
    }

    /// すでに書いたところへ書き戻す
    fn patch(&mut self, offset: u64, data: &[u8]) -> Result<(), Error> {
        self.file.flush()?;
        let file = self.file.get_mut();
        file.seek(SeekFrom::Start(offset))?;
        file.write_all(data)?;
        file.seek(SeekFrom::End(0))?;
        Ok(())
    }
}


/// ローカルヘッダを組み立てる
fn local_header(
    name: &str,
    method: u16,
    crc: u32,
    compressed: u64,
    uncompressed: u64,
    time: u16,
    date: u16,
    big: bool,
) -> Vec<u8> {
    let mut header = Vec::with_capacity(30 + name.len() + 20);
    header.extend_from_slice(&0x04034b50u32.to_le_bytes());
    header.extend_from_slice(&(if big {45u16} else {20u16}).to_le_bytes());
    header.extend_from_slice(&flags(name).to_le_bytes());
    header.extend_from_slice(&method.to_le_bytes());
    header.extend_from_slice(&time.to_le_bytes());
    header.extend_from_slice(&date.to_le_bytes());
    header.extend_from_slice(&crc.to_le_bytes());

    if big {
        header.extend_from_slice(&(LIMIT as u32).to_le_bytes());
        header.extend_from_slice(&(LIMIT as u32).to_le_bytes());
        header.extend_from_slice(&(name.len() as u16).to_le_bytes());
        header.extend_from_slice(&20u16.to_le_bytes());
        header.extend_from_slice(name.as_bytes());
        header.extend_from_slice(&1u16.to_le_bytes());
        header.extend_from_slice(&16u16.to_le_bytes());
        header.extend_from_slice(&uncompressed.to_le_bytes());
        header.extend_from_slice(&compressed.to_le_bytes());
        return header;
    }

    header.extend_from_slice(&(compressed as u32).to_le_bytes());
    header.extend_from_slice(&(uncompressed as u32).to_le_bytes());
    header.extend_from_slice(&(name.len() as u16).to_le_bytes());
    header.extend_from_slice(&0u16.to_le_bytes());
    header.extend_from_slice(name.as_bytes());
    header
}


/// 中央目録の 1 エントリを足す
fn central_header(region: &mut Vec<u8>, one: &Written) {
    let big = one.compressed >= LIMIT || one.uncompressed >= LIMIT || one.offset >= LIMIT;
    let mut extra = Vec::new();

    if big {
        extra.extend_from_slice(&1u16.to_le_bytes());
        extra.extend_from_slice(&24u16.to_le_bytes());
        extra.extend_from_slice(&one.uncompressed.to_le_bytes());
        extra.extend_from_slice(&one.compressed.to_le_bytes());
        extra.extend_from_slice(&one.offset.to_le_bytes());
    }

    region.extend_from_slice(&0x02014b50u32.to_le_bytes());
    region.extend_from_slice(&(if big {45u16} else {20u16}).to_le_bytes());
    region.extend_from_slice(&(if big {45u16} else {20u16}).to_le_bytes());
    region.extend_from_slice(&flags(&one.name).to_le_bytes());
    region.extend_from_slice(&one.method.to_le_bytes());
    region.extend_from_slice(&one.time.to_le_bytes());
    region.extend_from_slice(&one.date.to_le_bytes());
    region.extend_from_slice(&one.crc.to_le_bytes());
    region.extend_from_slice(&(one.compressed.min(LIMIT) as u32).to_le_bytes());
    region.extend_from_slice(&(one.uncompressed.min(LIMIT) as u32).to_le_bytes());
    region.extend_from_slice(&(one.name.len() as u16).to_le_bytes());
    region.extend_from_slice(&(extra.len() as u16).to_le_bytes());
    region.extend_from_slice(&0u16.to_le_bytes());
    region.extend_from_slice(&0u16.to_le_bytes());
    region.extend_from_slice(&0u16.to_le_bytes());
    region.extend_from_slice(&0u32.to_le_bytes());
    region.extend_from_slice(&(one.offset.min(LIMIT) as u32).to_le_bytes());
    region.extend_from_slice(one.name.as_bytes());
    region.extend_from_slice(&extra);
}


/// 名前が ASCII でなければ、UTF-8 の印を立てる
fn flags(name: &str) -> u16 {
    if name.is_ascii() {
        0
    } else {
        0x0800
    }
}


/// 中央目録の 1 エントリを読む
fn read_entry(region: &[u8], cursor: usize) -> Result<Entry, Error> {
    let method = u16(region, cursor + 10)?;
    let crc = u32(region, cursor + 16)?;
    let mut compressed = u32(region, cursor + 20)? as u64;
    let mut uncompressed = u32(region, cursor + 24)? as u64;
    let name_length = u16(region, cursor + 28)? as usize;
    let extra_length = u16(region, cursor + 30)? as usize;
    let mut offset = u32(region, cursor + 42)? as u64;

    let start = cursor + 46;

    if start + name_length + extra_length > region.len() {
        return Err(Error::new("中央目録が途中で終わっています"));
    }

    let name = String::from_utf8_lossy(&region[start..start + name_length]).into_owned();
    let extra = &region[start + name_length..start + name_length + extra_length];
    let mut cursor = 0;

    while cursor + 4 <= extra.len() {
        let kind = u16(extra, cursor)?;
        let length = u16(extra, cursor + 2)? as usize;
        let body = cursor + 4;

        if body + length > extra.len() {
            break;
        }

        if kind == 1 {
            // 32 ビットに収まらなかったものだけが、この順に入っている
            let mut place = body;

            if uncompressed == LIMIT && place + 8 <= body + length {
                uncompressed = u64_at(extra, place)?;
                place += 8;
            }

            if compressed == LIMIT && place + 8 <= body + length {
                compressed = u64_at(extra, place)?;
                place += 8;
            }

            if offset == LIMIT && place + 8 <= body + length {
                offset = u64_at(extra, place)?;
            }
        }

        cursor = body + length;
    }

    Ok(Entry {name, method, crc, compressed, uncompressed, offset})
}


/// 末尾から中央目録の終わりの印を探す
fn find_end(region: &[u8]) -> Result<usize, Error> {
    if region.len() < 22 {
        return Err(Error::new("ZIP として短すぎます"));
    }

    let mut cursor = region.len() - 22;

    loop {
        if u32(region, cursor)? == 0x06054b50 {
            let comment = u16(region, cursor + 20)? as usize;

            if cursor + 22 + comment == region.len() {
                return Ok(cursor);
            }
        }

        if cursor == 0 {
            return Err(Error::new("ZIP の中央目録が見つかりません"));
        }

        cursor -= 1;
    }
}


/// ZIP64 の中央目録の在り処を指す印を探す
fn find_locator(region: &[u8], end: usize) -> Result<usize, Error> {
    if end < 20 {
        return Err(Error::new("ZIP64 の目印が見つかりません"));
    }

    let cursor = end - 20;

    if u32(region, cursor)? != 0x07064b50 {
        return Err(Error::new("ZIP64 の目印が見つかりません"));
    }

    Ok(cursor)
}


/// 2 バイトを読む
fn u16(region: &[u8], offset: usize) -> Result<u16, Error> {
    if offset + 2 > region.len() {
        return Err(Error::new("ZIP の記録が途中で終わっています"));
    }

    Ok(u16::from_le_bytes([region[offset], region[offset + 1]]))
}


/// 4 バイトを読む
fn u32(region: &[u8], offset: usize) -> Result<u32, Error> {
    if offset + 4 > region.len() {
        return Err(Error::new("ZIP の記録が途中で終わっています"));
    }

    Ok(u32::from_le_bytes([
        region[offset],
        region[offset + 1],
        region[offset + 2],
        region[offset + 3],
    ]))
}


/// 8 バイトを読む
fn u64_at(region: &[u8], offset: usize) -> Result<u64, Error> {
    if offset + 8 > region.len() {
        return Err(Error::new("ZIP の記録が途中で終わっています"));
    }

    let mut value = [0u8; 8];
    value.copy_from_slice(&region[offset..offset + 8]);
    Ok(u64::from_le_bytes(value))
}


/// いまの時刻を MS-DOS の形式で返す
fn now() -> (u16, u16) {
    let seconds = match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(value) => value.as_secs() as i64,
        Err(_) => 0,
    };

    let days = seconds.div_euclid(86400);
    let rest = seconds.rem_euclid(86400);
    let (year, month, day) = crate::date::civil(days);
    let hour = rest / 3600;
    let minute = (rest % 3600) / 60;
    let second = rest % 60;

    let time = ((hour as u16) << 11) | ((minute as u16) << 5) | (second as u16 / 2);
    let date = (((year - 1980).max(0) as u16) << 9) | ((month as u16) << 5) | day as u16;
    (time, date)
}