use super::{ProviderError, TreeRequest, TypeTreeProvider};
use crate::RawStr;
use crate::limits::{ChargeError, Meter, MeteredVec};
use crate::typetree::{NodeList, NodeRow, Tree, TreeError};
use std::fmt;
use std::sync::{Arc, Mutex};
pub trait ScriptGenerator: Send + Sync + fmt::Debug {
fn get_nodes(
&self,
assembly: &RawStr,
fullname: &RawStr,
) -> Result<Option<Arc<Tree>>, ProviderError>;
}
pub fn generator_node_list(mut rows: MeteredVec<NodeRow>) -> Result<NodeList, TreeError> {
let meter = rows.charge().meter().clone();
let mut bounds = crate::limits::TreeTraversal::new(&meter, u32::MAX);
for row in rows.as_mut_slice() {
bounds.step(0, 0, 1)?;
row.byte_size = 0;
row.version = 0;
row.type_flags = None;
row.variable_count = None;
row.index = None;
row.ref_type_hash = None;
}
meter.count_decode(
u64::try_from(rows.len())
.unwrap_or(u64::MAX)
.saturating_mul(8),
)?;
NodeList::from_rows(rows)
}
#[derive(Debug)]
pub struct DumpEntry {
assembly: RawStr,
fullname: RawStr,
tree: Arc<Tree>,
}
impl DumpEntry {
pub fn api(
assembly: RawStr,
namespace: &RawStr,
class: RawStr,
tree: Arc<Tree>,
meter: &Arc<Meter>,
) -> Result<Self, ChargeError> {
let fullname = if namespace.is_empty() {
class
} else {
copy_concat(&[namespace.as_bytes(), b".", class.as_bytes()], meter)?
};
Ok(Self::il2cpp(assembly, fullname, tree))
}
#[must_use]
pub fn il2cpp(assembly: RawStr, fullname: RawStr, tree: Arc<Tree>) -> Self {
Self {
assembly,
fullname,
tree,
}
}
}
#[derive(Debug)]
pub struct DumpProvider {
entries: MeteredVec<DumpEntry>,
}
impl DumpProvider {
#[must_use]
pub fn new(entries: MeteredVec<DumpEntry>) -> Self {
Self { entries }
}
}
impl ScriptGenerator for DumpProvider {
fn get_nodes(
&self,
assembly: &RawStr,
fullname: &RawStr,
) -> Result<Option<Arc<Tree>>, ProviderError> {
let meter = self.entries.charge().meter();
for e in self.entries.as_slice() {
if keys_match(meter, &e.assembly, &e.fullname, assembly, fullname)
.map_err(|e| refusal(e, Arc::from("script work refused")))?
{
return Ok(Some(e.tree.clone()));
}
}
Ok(None)
}
}
#[derive(Debug)]
struct Cached {
assembly: RawStr,
fullname: RawStr,
tree: Arc<Tree>,
}
#[derive(Debug)]
pub struct GeneratorProvider<G> {
generator: G,
cache: Mutex<MeteredVec<Cached>>,
meter: Arc<Meter>,
max_entries: usize,
refusal_detail: Arc<str>,
}
const _: () = {
crate::send_sync::<dyn ScriptGenerator>();
crate::send_sync::<DumpEntry>();
crate::send_sync::<DumpProvider>();
crate::send_sync::<GeneratorProvider<DumpProvider>>();
};
impl<G: ScriptGenerator> GeneratorProvider<G> {
#[must_use]
pub fn new(
generator: G,
meter: &Arc<Meter>,
max_entries: usize,
refusal_detail: Arc<str>,
) -> Self {
Self {
generator,
cache: Mutex::new(MeteredVec::new(meter)),
meter: meter.clone(),
max_entries,
refusal_detail,
}
}
#[must_use]
pub fn cached(&self) -> usize {
self.cache.lock().map_or(0, |c| c.len())
}
pub fn get_nodes_up(
&self,
assembly: &RawStr,
fullname: &RawStr,
) -> Result<Option<Arc<Tree>>, ProviderError> {
if let Ok(cache) = self.cache.lock() {
for c in cache.as_slice() {
if keys_match(&self.meter, &c.assembly, &c.fullname, assembly, fullname)
.map_err(|e| self.memory(e))?
{
return Ok(Some(c.tree.clone()));
}
}
}
let normalized;
self.meter
.count_decode(1 + u64::try_from(assembly.len().min(4)).unwrap_or(u64::MAX))
.map_err(|e| self.memory(e))?;
let lookup_assembly = if assembly.as_bytes().ends_with(b".dll") {
assembly
} else {
normalized = copy_concat(&[assembly.as_bytes(), b".dll"], &self.meter)
.map_err(|e| self.memory(e))?;
&normalized
};
let answer = self.generator.get_nodes(lookup_assembly, fullname)?;
if let Some(tree) = &answer
&& let Ok(mut cache) = self.cache.lock()
&& cache.len() < self.max_entries
{
for c in cache.as_slice() {
if keys_match(&self.meter, &c.assembly, &c.fullname, assembly, fullname)
.map_err(|e| self.memory(e))?
{
return Ok(answer);
}
}
let assembly =
copy_concat(&[assembly.as_bytes()], &self.meter).map_err(|e| self.memory(e))?;
let fullname =
copy_concat(&[fullname.as_bytes()], &self.meter).map_err(|e| self.memory(e))?;
cache
.push(Cached {
assembly,
fullname,
tree: tree.clone(),
})
.map_err(|e| self.memory(e))?;
}
Ok(answer)
}
fn memory(&self, error: ChargeError) -> ProviderError {
refusal(error, self.refusal_detail.clone())
}
}
impl<G: ScriptGenerator> TypeTreeProvider for GeneratorProvider<G> {
fn name(&self) -> &'static str {
"script"
}
fn accepts_scripts(&self) -> bool {
true
}
fn tree(&self, req: &TreeRequest<'_>) -> Result<Option<Arc<Tree>>, ProviderError> {
let Some(script) = req.script else {
return Ok(None);
};
let joined;
let fullname = if script.namespace.is_empty() {
&script.class
} else {
joined = copy_concat(
&[script.namespace.as_bytes(), b".", script.class.as_bytes()],
&self.meter,
)
.map_err(|e| self.memory(e))?;
&joined
};
self.get_nodes_up(&script.assembly, fullname)
}
}
fn refusal(error: ChargeError, detail: Arc<str>) -> ProviderError {
let mut out = ProviderError::new("script", detail);
match error {
ChargeError::Limit(l) => out.limit = Some(l),
ChargeError::Budget(b) => out.memory = Some(b),
ChargeError::Allocator(a) => out.allocator = Some(a),
}
out
}
fn same(meter: &Arc<Meter>, a: &RawStr, b: &RawStr) -> Result<bool, ChargeError> {
let bytes = if a.len() == b.len() { a.len() } else { 0 };
crate::limits::TreeTraversal::new(meter, u32::MAX).step(
0,
0,
1_u64.saturating_add(u64::try_from(bytes).unwrap_or(u64::MAX)),
)?;
Ok(a == b)
}
fn keys_match(
meter: &Arc<Meter>,
a: &RawStr,
f: &RawStr,
assembly: &RawStr,
fullname: &RawStr,
) -> Result<bool, ChargeError> {
Ok(same(meter, a, assembly)? && same(meter, f, fullname)?)
}
fn copy_concat(parts: &[&[u8]], meter: &Arc<Meter>) -> Result<RawStr, ChargeError> {
let bytes = parts.iter().fold(0_u64, |sum, p| {
sum.saturating_add(u64::try_from(p.len()).unwrap_or(u64::MAX))
});
meter.count_decode(bytes)?;
RawStr::charged_concat(parts, meter)
}