use crate::error::{Error, Result};
use std::ffi::CStr;
use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ReleaseType {
Current,
Stable,
Release,
Rc(u8),
}
impl fmt::Display for ReleaseType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ReleaseType::Current => write!(f, "CURRENT"),
ReleaseType::Stable => write!(f, "STABLE"),
ReleaseType::Release => write!(f, "RELEASE"),
ReleaseType::Rc(n) => write!(f, "RC{}", n),
}
}
}
#[derive(Debug, Clone)]
pub struct OsVersion {
pub major: u8,
pub minor: u8,
pub patch: Option<u8>,
pub release_type: ReleaseType,
}
impl OsVersion {
pub fn detect_kernel() -> Result<Self> {
let mut utsname: libc::utsname = unsafe { std::mem::zeroed() };
let result = unsafe { libc::uname(&mut utsname) };
if result != 0 {
return Err(Error::CommandFailed {
command: "uname(2) syscall".to_string(),
message: format!("uname syscall failed with code {}", result),
});
}
let release_cstr = unsafe { CStr::from_ptr(utsname.release.as_ptr()) };
let version_str = release_cstr
.to_str()
.map_err(|e| Error::InvalidVersion(format!("Invalid UTF-8 in uname.release: {}", e)))?
.to_string();
Self::parse(&version_str)
}
fn parse(s: &str) -> Result<Self> {
let parts: Vec<&str> = s.split('-').collect();
if parts.len() < 2 {
return Err(Error::InvalidVersion(format!(
"Invalid version format: {}",
s
)));
}
let version_nums: Vec<&str> = parts[0].split('.').collect();
if version_nums.len() != 2 {
return Err(Error::InvalidVersion(format!(
"Invalid version number: {}",
parts[0]
)));
}
let major = version_nums[0].parse::<u8>().map_err(|_| {
Error::InvalidVersion(format!("Invalid major version: {}", version_nums[0]))
})?;
let minor = version_nums[1].parse::<u8>().map_err(|_| {
Error::InvalidVersion(format!("Invalid minor version: {}", version_nums[1]))
})?;
let release_type = match parts[1] {
"CURRENT" => ReleaseType::Current,
"STABLE" => ReleaseType::Stable,
"RELEASE" => ReleaseType::Release,
s if s.starts_with("RC") => {
let num = s
.strip_prefix("RC")
.and_then(|n| n.parse::<u8>().ok())
.unwrap_or(1);
ReleaseType::Rc(num)
}
_ => {
return Err(Error::InvalidVersion(format!(
"Unknown release type: {}",
parts[1]
)))
}
};
let patch = if parts.len() > 2 && parts[2].starts_with('p') {
parts[2]
.strip_prefix('p')
.and_then(|n| n.parse::<u8>().ok())
} else {
None
};
Ok(OsVersion {
major,
minor,
patch,
release_type,
})
}
pub fn supports_vlan_filtering(&self) -> bool {
self.major >= 15
}
#[allow(dead_code)]
pub fn supports_service_jails(&self) -> bool {
self.major >= 15
}
#[allow(dead_code)]
pub fn supports_zfs_dataset(&self) -> bool {
self.major >= 15
}
#[allow(dead_code)]
pub fn requires_pkgbase(&self) -> bool {
self.major >= 16
}
}
impl fmt::Display for OsVersion {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}.{}-{}", self.major, self.minor, self.release_type)?;
if let Some(patch) = self.patch {
write!(f, "-p{}", patch)?;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_current() {
let ver = OsVersion::parse("16.0-CURRENT").unwrap();
assert_eq!(ver.major, 16);
assert_eq!(ver.minor, 0);
assert_eq!(ver.patch, None);
assert_eq!(ver.release_type, ReleaseType::Current);
}
#[test]
fn test_parse_release() {
let ver = OsVersion::parse("15.0-RELEASE").unwrap();
assert_eq!(ver.major, 15);
assert_eq!(ver.minor, 0);
assert_eq!(ver.patch, None);
assert_eq!(ver.release_type, ReleaseType::Release);
}
#[test]
fn test_parse_release_with_patch() {
let ver = OsVersion::parse("15.0-RELEASE-p1").unwrap();
assert_eq!(ver.major, 15);
assert_eq!(ver.minor, 0);
assert_eq!(ver.patch, Some(1));
assert_eq!(ver.release_type, ReleaseType::Release);
}
#[test]
fn test_parse_stable() {
let ver = OsVersion::parse("14.2-STABLE").unwrap();
assert_eq!(ver.major, 14);
assert_eq!(ver.minor, 2);
assert_eq!(ver.release_type, ReleaseType::Stable);
}
#[test]
fn test_parse_rc() {
let ver = OsVersion::parse("15.0-RC2").unwrap();
assert_eq!(ver.major, 15);
assert_eq!(ver.minor, 0);
assert_eq!(ver.release_type, ReleaseType::Rc(2));
}
#[test]
fn test_vlan_filtering_support() {
assert!(OsVersion::parse("15.0-RELEASE").unwrap().supports_vlan_filtering());
assert!(OsVersion::parse("16.0-CURRENT").unwrap().supports_vlan_filtering());
assert!(!OsVersion::parse("14.2-STABLE").unwrap().supports_vlan_filtering());
assert!(!OsVersion::parse("13.3-RELEASE").unwrap().supports_vlan_filtering());
}
#[test]
fn test_display() {
assert_eq!(OsVersion::parse("16.0-CURRENT").unwrap().to_string(), "16.0-CURRENT");
assert_eq!(OsVersion::parse("15.0-RELEASE-p1").unwrap().to_string(), "15.0-RELEASE-p1");
}
}