// Copyright 2024 Koutheir Attouchi.
// See the "LICENSE.txt" file at the top-level directory of this distribution.
//
// Licensed under the MIT license. This file may not be copied, modified,
// or distributed except according to those terms.

//! Cache of the GNU/Linux old dynamic loader.

#[cfg(test)]
mod tests;

use core::ffi::{c_uint, CStr};
use core::iter::FusedIterator;
use core::mem::{offset_of, size_of};
use std::path::{Path, PathBuf};

use memmap2::Mmap;
use nom::bytes::complete::{tag as nom_tag, take as nom_take};
use nom::combinator::peek as nom_peek;
use nom::number::complete::u32 as nom_u32;
use nom::number::Endianness;
use nom::sequence::{preceded as nom_preceded, tuple as nom_tuple};
use nom::IResult;
use static_assertions::assert_eq_size;

use crate::utils::{cstr_entry_to_crate_entry, map_file};
use crate::{CacheProvider, Error, Result};

static CACHE_FILE_PATH: &str = "/etc/ld.so.cache";

static MAGIC: &[u8] = b"ld.so-1.7.0";

#[repr(C)]
struct Header {
    magic: [u8; 11],
    padding: [u8; 1],
    lib_count: c_uint,
}

#[repr(C)]
struct Entry {
    flags: u32,
    key: u32,
    value: u32,
}

/// Cache of the GNU/Linux old dynamic loader.
///
/// This loads a dynamic loader cache file (*e.g.*, `/etc/ld.so.cache`),
/// in the old `ld.so-1.7.0` format, for either 32-bits or 64-bits architectures,
/// in either little-endian or big-endian byte order.
#[derive(Debug)]
pub struct Cache {
    path: PathBuf,
    map: Mmap,
    lib_count: u32,
}

impl Cache {
    /// Create a cache that loads the file `/etc/ld.so.cache`.
    pub fn load_default() -> Result<Self> {
        Self::load(CACHE_FILE_PATH)
    }

    /// Create a cache that loads the specified cache file.
    pub fn load(path: impl AsRef<Path>) -> Result<Self> {
        let path = path.as_ref();
        let map = map_file(path)?;
        let (_, lib_count) =
            Self::parse_header(&map).map_err(|r| Error::from_nom_parse(r, &map, path))?;

        Ok(Self {
            path: path.into(),
            map,
            lib_count,
        })
    }

    fn parse_header(bytes: &[u8]) -> IResult<&[u8], u32> {
        assert_eq_size!(u32, c_uint);

        let (input, lib_count) = nom_preceded(
            nom_preceded(
                nom_tag(MAGIC),
                nom_take(offset_of!(Header, lib_count) - MAGIC.len()),
            ),
            nom_u32(Endianness::Native),
        )(bytes)?;

        let max_lib_count = bytes
            .len()
            .saturating_sub(size_of::<Header>())
            .saturating_div(size_of::<Entry>()) as u32;

        if lib_count > max_lib_count {
            return Err(nom::Err::Error(nom::error::make_error(
                bytes,
                nom::error::ErrorKind::TooLarge,
            )));
        }

        let min_size = size_of::<Header>()
            .saturating_add(size_of::<Entry>().saturating_mul(lib_count as usize));
        nom_peek(nom_take(min_size))(bytes)?;

        Ok((input, lib_count))
    }

    /// Return an iterator that returns cache entries.
    pub fn iter(&self) -> Result<impl FusedIterator<Item = Result<crate::Entry<'_>>> + '_> {
        let entries_end = size_of::<Header>()
            .saturating_add(size_of::<Entry>().saturating_mul(self.lib_count as usize));
        let entries_bytes = &self.map[size_of::<Header>()..entries_end];

        Ok(Iter {
            path: &self.path,
            entries_bytes,
            string_table: &self.map[entries_end..],
        })
    }
}

impl CacheProvider for Cache {
    fn entries_iter<'cache>(
        &'cache self,
    ) -> Result<Box<dyn FusedIterator<Item = Result<crate::Entry<'cache>>> + 'cache>> {
        let iter = self.iter()?;
        Ok(Box::new(iter))
    }
}

#[derive(Debug)]
struct Iter<'cache> {
    path: &'cache Path,
    entries_bytes: &'cache [u8],
    string_table: &'cache [u8],
}

impl<'cache> Iter<'cache> {
    fn next_fallible(&mut self) -> Result<crate::Entry<'cache>> {
        let (input, (key, value)) = nom_tuple((
            nom_preceded(
                nom_take(offset_of!(Entry, key)),
                nom_u32(Endianness::Native),
            ),
            nom_u32(Endianness::Native),
        ))(self.entries_bytes)
        .map_err(|r| Error::from_nom_parse(r, self.entries_bytes, self.path))?;

        self.entries_bytes = input;

        let key = self
            .string_table
            .get((key as usize)..)
            .ok_or(Error::OffsetIsInvalid {
                path: self.path.into(),
            })?;
        let key = CStr::from_bytes_until_nul(key)?;

        let value = self
            .string_table
            .get((value as usize)..)
            .ok_or(Error::OffsetIsInvalid {
                path: self.path.into(),
            })?;
        let value = CStr::from_bytes_until_nul(value)?;

        cstr_entry_to_crate_entry(key, value)
    }
}

impl<'cache> Iterator for Iter<'cache> {
    type Item = Result<crate::Entry<'cache>>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.entries_bytes.len() < size_of::<Entry>() {
            None
        } else {
            Some(self.next_fallible())
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let remaining = self.entries_bytes.len() / size_of::<Entry>();
        (remaining, Some(remaining))
    }
}

impl<'cache> FusedIterator for Iter<'cache> {}

impl<'cache> ExactSizeIterator for Iter<'cache> {}