use crate::host::with_host;
use fusevm::Value;
use std::net::{Ipv4Addr, Ipv6Addr};
use std::sync::LazyLock;
const FILTER_DEFAULT: i64 = 516; const FILTER_VALIDATE_INT: i64 = 257;
const FILTER_VALIDATE_BOOLEAN: i64 = 258;
const FILTER_VALIDATE_FLOAT: i64 = 259;
const FILTER_VALIDATE_REGEXP: i64 = 272;
const FILTER_VALIDATE_URL: i64 = 273;
const FILTER_VALIDATE_EMAIL: i64 = 274;
const FILTER_VALIDATE_IP: i64 = 275;
const FILTER_VALIDATE_MAC: i64 = 276;
const FILTER_VALIDATE_DOMAIN: i64 = 277;
const FILTER_SANITIZE_STRING: i64 = 513; const FILTER_SANITIZE_SPECIAL_CHARS: i64 = 515;
const FILTER_SANITIZE_EMAIL: i64 = 517;
const FILTER_SANITIZE_URL: i64 = 518;
const FILTER_SANITIZE_NUMBER_INT: i64 = 519;
const FILTER_SANITIZE_NUMBER_FLOAT: i64 = 520;
const FILTER_SANITIZE_FULL_SPECIAL_CHARS: i64 = 522;
const FLAG_ALLOW_OCTAL: i64 = 1;
const FLAG_ALLOW_HEX: i64 = 2;
const FLAG_ALLOW_FRACTION: i64 = 4096;
const FLAG_ALLOW_THOUSAND: i64 = 8192;
const FLAG_ALLOW_SCIENTIFIC: i64 = 16384;
const FLAG_IPV4: i64 = 1048576;
const FLAG_IPV6: i64 = 2097152;
const FLAG_HOSTNAME: i64 = 1048576; const FLAG_NULL_ON_FAILURE: i64 = 134217728;
pub fn dispatch(name: &str, args: &[Value]) -> Option<Result<Value, String>> {
let v = match name {
"filter_var" => filter_var(args),
"filter_var_array" => filter_var_array(args),
"filter_has_var" => filter_has_var(args),
_ => return None,
};
Some(Ok(v))
}
fn filter_var(args: &[Value]) -> Value {
let input = args.first().cloned().unwrap_or(Value::Undef);
let filter_id = args.get(1).map(resolve_filter_id).unwrap_or(FILTER_DEFAULT);
let cfg = args.get(2).cloned().unwrap_or(Value::Undef);
let (flags, options) = parse_config(&cfg);
apply_filter(&input, filter_id, flags, &options)
}
fn filter_var_array(args: &[Value]) -> Value {
let data = args.first().cloned().unwrap_or(Value::Undef);
let Some(data_pairs) = with_host(|h| h.array_pairs(&data)) else {
return Value::bool(false);
};
let definition = args.get(1).cloned().unwrap_or(Value::Undef);
if let Some(def_pairs) = with_host(|h| h.array_pairs(&definition)) {
let mut out: Vec<(Value, Value)> = Vec::with_capacity(def_pairs.len());
for (field, spec) in &def_pairs {
let found = data_pairs.iter().find(|(k, _)| value_key_eq(k, field));
let result = match found {
Some((_, value)) => {
let (id, flags, options) = resolve_spec(spec);
apply_filter(value, id, flags, &options)
}
None => Value::Undef,
};
out.push((field.clone(), result));
}
return make_map(out);
}
let id = resolve_filter_id(&definition);
let mut out: Vec<(Value, Value)> = Vec::with_capacity(data_pairs.len());
for (field, value) in &data_pairs {
out.push((field.clone(), apply_filter(value, id, 0, &None)));
}
make_map(out)
}
fn resolve_spec(spec: &Value) -> (i64, i64, Option<Value>) {
if with_host(|h| h.is_array(spec)) {
let id = map_get(spec, "filter")
.map(|v| resolve_filter_id(&v))
.unwrap_or(FILTER_DEFAULT);
let flags = map_get(spec, "flags").map(|v| flag_value(&v)).unwrap_or(0);
let options = map_get(spec, "options");
return (id, flags, options);
}
(resolve_filter_id(spec), 0, None)
}
fn parse_config(cfg: &Value) -> (i64, Option<Value>) {
if with_host(|h| h.is_array(cfg)) {
let flags = map_get(cfg, "flags").map(|v| flag_value(&v)).unwrap_or(0);
let options = map_get(cfg, "options");
return (flags, options);
}
(flag_value(cfg), None)
}
fn map_get(arr: &Value, key: &str) -> Option<Value> {
with_host(|h| {
h.array_pairs(arr)?
.into_iter()
.find(|(k, _)| h.to_str(k) == key)
.map(|(_, v)| v)
})
}
fn opt_get(options: &Option<Value>, key: &str) -> Option<Value> {
options.as_ref().and_then(|o| map_get(o, key))
}
fn resolve_filter_id(v: &Value) -> i64 {
match v {
Value::Int(n) => *n,
Value::Str(s) => match s.as_str() {
"FILTER_DEFAULT" | "FILTER_UNSAFE_RAW" => FILTER_DEFAULT,
"FILTER_VALIDATE_INT" => FILTER_VALIDATE_INT,
"FILTER_VALIDATE_BOOLEAN" | "FILTER_VALIDATE_BOOL" => FILTER_VALIDATE_BOOLEAN,
"FILTER_VALIDATE_FLOAT" => FILTER_VALIDATE_FLOAT,
"FILTER_VALIDATE_REGEXP" => FILTER_VALIDATE_REGEXP,
"FILTER_VALIDATE_URL" => FILTER_VALIDATE_URL,
"FILTER_VALIDATE_EMAIL" => FILTER_VALIDATE_EMAIL,
"FILTER_VALIDATE_IP" => FILTER_VALIDATE_IP,
"FILTER_VALIDATE_MAC" => FILTER_VALIDATE_MAC,
"FILTER_VALIDATE_DOMAIN" => FILTER_VALIDATE_DOMAIN,
"FILTER_SANITIZE_STRING" | "FILTER_SANITIZE_STRIPPED" => FILTER_SANITIZE_STRING,
"FILTER_SANITIZE_SPECIAL_CHARS" => FILTER_SANITIZE_SPECIAL_CHARS,
"FILTER_SANITIZE_FULL_SPECIAL_CHARS" => FILTER_SANITIZE_FULL_SPECIAL_CHARS,
"FILTER_SANITIZE_EMAIL" => FILTER_SANITIZE_EMAIL,
"FILTER_SANITIZE_URL" => FILTER_SANITIZE_URL,
"FILTER_SANITIZE_NUMBER_INT" => FILTER_SANITIZE_NUMBER_INT,
"FILTER_SANITIZE_NUMBER_FLOAT" => FILTER_SANITIZE_NUMBER_FLOAT,
_ => FILTER_DEFAULT,
},
_ => FILTER_DEFAULT,
}
}
fn flag_value(v: &Value) -> i64 {
match v {
Value::Int(n) => *n,
Value::Str(s) => match s.as_str() {
"FILTER_FLAG_ALLOW_OCTAL" => FLAG_ALLOW_OCTAL,
"FILTER_FLAG_ALLOW_HEX" => FLAG_ALLOW_HEX,
"FILTER_FLAG_ALLOW_FRACTION" => FLAG_ALLOW_FRACTION,
"FILTER_FLAG_ALLOW_THOUSAND" => FLAG_ALLOW_THOUSAND,
"FILTER_FLAG_ALLOW_SCIENTIFIC" => FLAG_ALLOW_SCIENTIFIC,
"FILTER_FLAG_IPV4" => FLAG_IPV4,
"FILTER_FLAG_IPV6" => FLAG_IPV6,
"FILTER_FLAG_HOSTNAME" | "FILTER_FLAG_EMAIL_UNICODE" => FLAG_HOSTNAME,
"FILTER_NULL_ON_FAILURE" => FLAG_NULL_ON_FAILURE,
_ => 0,
},
_ => 0,
}
}
fn apply_filter(input: &Value, filter_id: i64, flags: i64, options: &Option<Value>) -> Value {
if with_host(|h| h.is_array(input)) {
return fail(flags);
}
let s = with_host(|h| h.to_str(input));
match filter_id {
FILTER_VALIDATE_INT => match validate_int(&s, flags, options) {
Some(n) => Value::int(n),
None => fail(flags),
},
FILTER_VALIDATE_FLOAT => match validate_float(&s, flags, options) {
Some(f) => Value::float(f),
None => fail(flags),
},
FILTER_VALIDATE_BOOLEAN => match validate_bool(&s) {
Some(b) => Value::bool(b),
None => fail(flags),
},
FILTER_VALIDATE_EMAIL => pass_or_fail(&s, validate_email(&s), flags),
FILTER_VALIDATE_URL => pass_or_fail(&s, validate_url(&s), flags),
FILTER_VALIDATE_IP => pass_or_fail(&s, validate_ip(&s, flags), flags),
FILTER_VALIDATE_MAC => pass_or_fail(&s, validate_mac(&s), flags),
FILTER_VALIDATE_DOMAIN => pass_or_fail(&s, validate_domain(&s, flags), flags),
FILTER_VALIDATE_REGEXP => pass_or_fail(&s, validate_regexp(&s, options), flags),
FILTER_SANITIZE_STRING => Value::str(sanitize_string(&s)),
FILTER_SANITIZE_SPECIAL_CHARS => Value::str(sanitize_special_chars(&s)),
FILTER_SANITIZE_FULL_SPECIAL_CHARS => Value::str(sanitize_full_special_chars(&s)),
FILTER_SANITIZE_EMAIL => Value::str(sanitize_keep(&s, is_email_char)),
FILTER_SANITIZE_URL => Value::str(sanitize_keep(&s, is_url_char)),
FILTER_SANITIZE_NUMBER_INT => Value::str(sanitize_keep(&s, is_number_int_char)),
FILTER_SANITIZE_NUMBER_FLOAT => Value::str(sanitize_number_float(&s, flags)),
_ => Value::str(s),
}
}
fn fail(flags: i64) -> Value {
if flags & FLAG_NULL_ON_FAILURE != 0 {
Value::Undef
} else {
Value::bool(false)
}
}
fn pass_or_fail(s: &str, ok: bool, flags: i64) -> Value {
if ok {
Value::str(s.to_string())
} else {
fail(flags)
}
}
fn validate_int(s: &str, flags: i64, options: &Option<Value>) -> Option<i64> {
let t = php_trim(s);
if t.is_empty() {
return None;
}
let value: i64 = if flags & FLAG_ALLOW_HEX != 0 && (t.starts_with("0x") || t.starts_with("0X"))
{
if t.len() <= 2 {
return None; }
i64::from_str_radix(&t[2..], 16).ok()?
} else if flags & FLAG_ALLOW_OCTAL != 0
&& t.len() > 1
&& t.starts_with('0')
&& t.bytes().all(|b| b.is_ascii_digit())
{
i64::from_str_radix(&t[1..], 8).ok()?
} else {
let digits = t
.strip_prefix('-')
.or_else(|| t.strip_prefix('+'))
.unwrap_or(t);
if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
if digits.len() > 1 && digits.starts_with('0') {
return None;
}
t.parse::<i64>().ok()?
};
if let Some(min) = opt_get(options, "min_range") {
if value < min.to_int() {
return None;
}
}
if let Some(max) = opt_get(options, "max_range") {
if value > max.to_int() {
return None;
}
}
Some(value)
}
fn validate_float(s: &str, flags: i64, options: &Option<Value>) -> Option<f64> {
let mut t = php_trim(s).to_string();
if t.is_empty() {
return None;
}
if flags & FLAG_ALLOW_THOUSAND != 0 {
t = t.replace(',', "");
if t.is_empty() {
return None;
}
}
if !t
.bytes()
.all(|b| b.is_ascii_digit() || matches!(b, b'+' | b'-' | b'.' | b'e' | b'E'))
{
return None;
}
let value: f64 = t.parse().ok()?;
if !value.is_finite() {
return None;
}
if let Some(min) = opt_get(options, "min_range") {
if value < min.to_float() {
return None;
}
}
if let Some(max) = opt_get(options, "max_range") {
if value > max.to_float() {
return None;
}
}
Some(value)
}
fn validate_bool(s: &str) -> Option<bool> {
match php_trim(s).to_ascii_lowercase().as_str() {
"1" | "true" | "on" | "yes" => Some(true),
"0" | "false" | "off" | "no" | "" => Some(false),
_ => None,
}
}
static EMAIL_RE: LazyLock<regex::Regex> = LazyLock::new(|| {
regex::Regex::new(
r"(?i)^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)+$",
)
.expect("email regex compiles")
});
fn validate_email(s: &str) -> bool {
s.len() <= 320 && EMAIL_RE.is_match(s)
}
static URL_RE: LazyLock<regex::Regex> = LazyLock::new(|| {
regex::Regex::new(
r"(?i)^[a-z][a-z0-9+.\-]*://([^\s/@]+@)?[^\s/:?#]+(:[0-9]+)?(/[^\s?#]*)?(\?[^\s#]*)?(#[^\s]*)?$",
)
.expect("url regex compiles")
});
fn validate_url(s: &str) -> bool {
URL_RE.is_match(s)
}
fn validate_ip(s: &str, flags: i64) -> bool {
let want4 = flags & FLAG_IPV4 != 0;
let want6 = flags & FLAG_IPV6 != 0;
let is4 = s.parse::<Ipv4Addr>().is_ok();
let is6 = s.parse::<Ipv6Addr>().is_ok();
match (want4, want6) {
(true, false) => is4,
(false, true) => is6,
_ => is4 || is6,
}
}
fn validate_mac(s: &str) -> bool {
let b = s.as_bytes();
match b.len() {
17 => {
let sep = b[2];
if sep != b':' && sep != b'-' {
return false;
}
for i in 0..6 {
let base = i * 3;
if !b[base].is_ascii_hexdigit() || !b[base + 1].is_ascii_hexdigit() {
return false;
}
if i < 5 && b[base + 2] != sep {
return false;
}
}
true
}
14 => {
for (i, &c) in b.iter().enumerate() {
if i == 4 || i == 9 {
if c != b'.' {
return false;
}
} else if !c.is_ascii_hexdigit() {
return false;
}
}
true
}
_ => false,
}
}
static HOSTNAME_RE: LazyLock<regex::Regex> = LazyLock::new(|| {
regex::Regex::new(
r"(?i)^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$",
)
.expect("hostname regex compiles")
});
fn validate_domain(s: &str, flags: i64) -> bool {
if s.is_empty() || s.len() > 253 {
return false;
}
if flags & FLAG_HOSTNAME != 0 {
return HOSTNAME_RE.is_match(s);
}
true
}
fn validate_regexp(s: &str, options: &Option<Value>) -> bool {
let Some(pat_val) = opt_get(options, "regexp") else {
return false;
};
let pattern = with_host(|h| h.to_str(&pat_val));
let Some(re) = crate::stdlib::preg::compile_for("filter_var", &pattern) else {
return false;
};
re.is_match(s.as_bytes())
}
fn sanitize_string(s: &str) -> String {
let stripped = strip_tags(s);
let mut out = String::with_capacity(stripped.len());
for c in stripped.chars() {
match c {
'"' => out.push_str("""),
'\'' => out.push_str("'"),
_ => out.push(c),
}
}
out
}
fn sanitize_special_chars(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
match c {
'&' => out.push_str("&"),
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'"' => out.push_str("""),
'\'' => out.push_str("'"),
_ => out.push(c),
}
}
out
}
fn sanitize_full_special_chars(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
match c {
'&' => out.push_str("&"),
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'"' => out.push_str("""),
'\'' => out.push_str("'"),
_ => out.push(c),
}
}
out
}
fn sanitize_number_float(s: &str, flags: i64) -> String {
let allow_frac = flags & FLAG_ALLOW_FRACTION != 0;
let allow_thou = flags & FLAG_ALLOW_THOUSAND != 0;
let allow_sci = flags & FLAG_ALLOW_SCIENTIFIC != 0;
s.chars()
.filter(|&c| {
c.is_ascii_digit()
|| matches!(c, '+' | '-')
|| (allow_frac && c == '.')
|| (allow_thou && c == ',')
|| (allow_sci && matches!(c, 'e' | 'E'))
})
.collect()
}
fn sanitize_keep(s: &str, keep: fn(char) -> bool) -> String {
s.chars().filter(|&c| keep(c)).collect()
}
fn is_email_char(c: char) -> bool {
c.is_ascii_alphanumeric()
|| matches!(
c,
'!' | '#'
| '$'
| '%'
| '&'
| '\''
| '*'
| '+'
| '-'
| '='
| '?'
| '^'
| '_'
| '`'
| '{'
| '|'
| '}'
| '~'
| '@'
| '.'
| '['
| ']'
)
}
fn is_url_char(c: char) -> bool {
c.is_ascii_alphanumeric()
|| matches!(
c,
'$' | '-'
| '_'
| '.'
| '+'
| '!'
| '*'
| '\''
| '('
| ')'
| ','
| '{'
| '}'
| '|'
| '\\'
| '^'
| '~'
| '['
| ']'
| '`'
| '<'
| '>'
| '#'
| '%'
| '"'
| ';'
| '/'
| '?'
| ':'
| '@'
| '&'
| '='
)
}
fn is_number_int_char(c: char) -> bool {
c.is_ascii_digit() || matches!(c, '+' | '-')
}
fn strip_tags(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut in_tag = false;
for c in s.chars() {
match c {
'<' => in_tag = true,
'>' => in_tag = false,
_ if !in_tag => out.push(c),
_ => {}
}
}
out
}
fn filter_has_var(_args: &[Value]) -> Value {
Value::bool(false)
}
fn php_trim(s: &str) -> &str {
s.trim_matches(|c: char| matches!(c, ' ' | '\t' | '\n' | '\r' | '\u{0b}' | '\u{0c}'))
}
fn make_map(pairs: Vec<(Value, Value)>) -> Value {
with_host(|h| {
let arr = h.new_array();
for (k, v) in pairs {
h.arr_set_key(&arr, &k, v);
}
arr
})
}
fn value_key_eq(a: &Value, b: &Value) -> bool {
with_host(|h| h.to_str(a) == h.to_str(b))
}