forked from NationTech/harmony
2016 lines
58 KiB
Rust
2016 lines
58 KiB
Rust
use crate::data::dhcpd::Dhcpd;
|
|
use yaserde::{MaybeString, RawXml};
|
|
use log::error;
|
|
use yaserde_derive::{YaDeserialize, YaSerialize};
|
|
|
|
impl From<String> for OPNsense {
|
|
fn from(content: String) -> Self {
|
|
yaserde::de::from_str(&content)
|
|
.map_err(|e| error!("{}", e.to_string()))
|
|
.expect("OPNSense received invalid string, should be full XML")
|
|
}
|
|
}
|
|
|
|
impl OPNsense {
|
|
pub fn to_xml(&self) -> String {
|
|
yaserde::ser::to_string(self)
|
|
.map_err(|e| error!("{}", e.to_string()))
|
|
.expect("OPNSense could not serialize to XML")
|
|
}
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
#[yaserde(rename = "opnsense")]
|
|
pub struct OPNsense {
|
|
pub theme: String,
|
|
pub sysctl: Sysctl,
|
|
pub system: RawXml,
|
|
pub interfaces: RawXml,
|
|
pub dhcpd: Dhcpd,
|
|
pub snmpd: Snmpd,
|
|
pub syslog: Syslog,
|
|
pub nat: Nat,
|
|
pub filter: Filters,
|
|
pub load_balancer: LoadBalancer,
|
|
pub ntpd: Ntpd,
|
|
pub widgets: Widgets,
|
|
pub revision: Revision,
|
|
#[yaserde(rename = "OPNsense")]
|
|
pub opnsense: OPNsenseXmlSection,
|
|
pub staticroutes: StaticRoutes,
|
|
pub ca: MaybeString,
|
|
pub gateways: Gateways,
|
|
pub cert: Cert,
|
|
pub dhcpdv6: DhcpDv6,
|
|
pub virtualip: VirtualIp,
|
|
pub openvpn: OpenVpn,
|
|
pub ppps: Ppps,
|
|
pub dyndnses: Dyndnses,
|
|
pub vlans: Vlans,
|
|
pub bridges: Bridges,
|
|
pub gifs: Gifs,
|
|
pub gres: Gres,
|
|
pub laggs: Laggs,
|
|
pub wireless: Wireless,
|
|
pub hasync: Hasync,
|
|
pub ifgroups: Ifgroups,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct LoadBalancer {
|
|
pub monitor_type: Vec<MonitorType>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct MonitorType {
|
|
pub name: String,
|
|
#[yaserde(rename = "type")]
|
|
pub r#type: String,
|
|
pub descr: String,
|
|
pub options: Option<Options>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Ntpd {
|
|
pub prefer: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Widgets {
|
|
pub sequence: String,
|
|
pub column_count: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Revision {
|
|
pub username: String,
|
|
pub time: f64,
|
|
pub description: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Options {
|
|
pub path: Option<MaybeString>,
|
|
pub host: Option<MaybeString>,
|
|
pub code: Option<MaybeString>,
|
|
pub send: Option<MaybeString>,
|
|
pub expect: Option<MaybeString>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Filters {
|
|
#[yaserde(rename = "rule")]
|
|
pub rules: Vec<Rule>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Rule {
|
|
#[yaserde(attribute)]
|
|
pub uuid: Option<String>,
|
|
#[yaserde(rename = "associated-rule-id")]
|
|
pub associated_rule_id: Option<MaybeString>,
|
|
#[yaserde(rename = "type")]
|
|
pub r#type: Option<MaybeString>,
|
|
pub interface: String,
|
|
pub ipprotocol: String,
|
|
pub statetype: Option<MaybeString>,
|
|
pub descr: Option<MaybeString>,
|
|
pub direction: Option<MaybeString>,
|
|
pub category: Option<MaybeString>,
|
|
pub quick: Option<MaybeString>,
|
|
pub protocol: Option<MaybeString>,
|
|
pub source: Source,
|
|
pub icmptype: Option<MaybeString>,
|
|
pub destination: Destination,
|
|
pub updated: Option<Updated>,
|
|
pub created: Option<Created>,
|
|
pub disabled: Option<MaybeString>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Source {
|
|
pub any: Option<u8>,
|
|
pub network: Option<MaybeString>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Destination {
|
|
pub network: Option<MaybeString>,
|
|
pub address: Option<MaybeString>,
|
|
pub port: Option<MaybeString>,
|
|
pub any: Option<MaybeString>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Username {
|
|
pub user: String,
|
|
pub host: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Sysctl {
|
|
pub item: Vec<SysctlItem>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct SysctlItem {
|
|
pub descr: String,
|
|
pub tunable: String,
|
|
pub value: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct System {
|
|
#[yaserde(rename = "use_mfs_tmp")]
|
|
pub use_mfs_tmp: MaybeString,
|
|
#[yaserde(rename = "use_mfs_var")]
|
|
pub use_mfs_var: MaybeString,
|
|
pub serialspeed: u32,
|
|
pub primaryconsole: String,
|
|
pub secondaryconsole: String,
|
|
pub optimization: String,
|
|
pub hostname: String,
|
|
pub domain: String,
|
|
pub group: Vec<Group>,
|
|
pub user: Vec<User>,
|
|
pub nextuid: u32,
|
|
pub nextgid: u32,
|
|
pub timezone: String,
|
|
pub timeservers: String,
|
|
pub webgui: WebGui,
|
|
pub usevirtualterminal: u8,
|
|
pub disableconsolemenu: u8,
|
|
pub disablevlanhwfilter: u8,
|
|
pub disablechecksumoffloading: u8,
|
|
pub disablesegmentationoffloading: u8,
|
|
pub disablelargereceiveoffloading: u8,
|
|
pub ipv6allow: u8,
|
|
pub powerd_ac_mode: String,
|
|
pub powerd_battery_mode: String,
|
|
pub powerd_normal_mode: String,
|
|
pub bogons: Bogons,
|
|
pub crypto_hardware: String,
|
|
pub pf_share_forward: u8,
|
|
pub lb_use_sticky: u8,
|
|
pub kill_states: u8,
|
|
pub ssh: Ssh,
|
|
pub firmware: Firmware,
|
|
pub sudo_allow_wheel: u8,
|
|
pub sudo_allow_group: String,
|
|
pub enablenatreflectionhelper: String,
|
|
pub rulesetoptimization: String,
|
|
pub maximumstates: MaybeString,
|
|
pub maximumfrags: MaybeString,
|
|
pub aliasesresolveinterval: MaybeString,
|
|
pub maximumtableentries: MaybeString,
|
|
pub language: String,
|
|
pub dnsserver: MaybeString,
|
|
#[yaserde(rename = "dns1gw")]
|
|
pub dns1gw: String,
|
|
#[yaserde(rename = "dns2gw")]
|
|
pub dns2gw: String,
|
|
#[yaserde(rename = "dns3gw")]
|
|
pub dns3gw: String,
|
|
#[yaserde(rename = "dns4gw")]
|
|
pub dns4gw: String,
|
|
#[yaserde(rename = "dns5gw")]
|
|
pub dns5gw: String,
|
|
#[yaserde(rename = "dns6gw")]
|
|
pub dns6gw: String,
|
|
#[yaserde(rename = "dns7gw")]
|
|
pub dns7gw: String,
|
|
#[yaserde(rename = "dns8gw")]
|
|
pub dns8gw: String,
|
|
pub dnsallowoverride: u8,
|
|
pub dnsallowoverride_exclude: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Ssh {
|
|
pub group: String,
|
|
pub noauto: u8,
|
|
pub interfaces: MaybeString,
|
|
pub kex: MaybeString,
|
|
pub ciphers: MaybeString,
|
|
pub macs: MaybeString,
|
|
pub keys: MaybeString,
|
|
pub enabled: String,
|
|
pub passwordauth: u8,
|
|
pub keysig: MaybeString,
|
|
pub permitrootlogin: u8,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Firmware {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub mirror: MaybeString,
|
|
pub flavour: MaybeString,
|
|
pub plugins: String,
|
|
#[yaserde(rename = "type")]
|
|
pub firmware_type: MaybeString,
|
|
pub subscription: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Bogons {
|
|
pub interval: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Group {
|
|
pub name: String,
|
|
pub description: String,
|
|
pub scope: String,
|
|
pub gid: u32,
|
|
pub member: Vec<u32>,
|
|
#[yaserde(rename = "priv")]
|
|
pub priv_: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct User {
|
|
pub name: String,
|
|
pub descr: MaybeString,
|
|
pub scope: String,
|
|
pub groupname: MaybeString,
|
|
pub password: String,
|
|
pub uid: u32,
|
|
pub expires: MaybeString,
|
|
pub authorizedkeys: MaybeString,
|
|
pub ipsecpsk: MaybeString,
|
|
pub otp_seed: MaybeString,
|
|
pub shell: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct WebGui {
|
|
pub protocol: String,
|
|
#[yaserde(rename = "ssl-certref")]
|
|
pub ssl_certref: String,
|
|
pub port: MaybeString,
|
|
#[yaserde(rename = "ssl-ciphers")]
|
|
pub ssl_ciphers: MaybeString,
|
|
pub interfaces: MaybeString,
|
|
|
|
pub compression: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct NumberOption {
|
|
item: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Range {
|
|
pub from: String,
|
|
pub to: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct StaticMap {
|
|
pub mac: String,
|
|
pub ipaddr: String,
|
|
pub hostname: String,
|
|
pub descr: Option<MaybeString>,
|
|
pub winsserver: MaybeString,
|
|
pub dnsserver: MaybeString,
|
|
pub ntpserver: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Snmpd {
|
|
pub syslocation: MaybeString,
|
|
pub syscontact: MaybeString,
|
|
pub rocommunity: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Syslog {
|
|
pub reverse: Option<MaybeString>,
|
|
pub preservelogs: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Nat {
|
|
#[yaserde(rename = "outbound")]
|
|
pub outbound: Outbound,
|
|
#[yaserde(rename = "rule")]
|
|
pub rules: Vec<NatRule>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Outbound {
|
|
pub mode: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct NatRule {
|
|
pub protocol: String,
|
|
pub interface: String,
|
|
pub category: MaybeString,
|
|
pub ipprotocol: String,
|
|
pub descr: MaybeString,
|
|
pub tag: MaybeString,
|
|
pub tagged: Option<MaybeString>,
|
|
pub poolopts: PoolOpts,
|
|
#[yaserde(rename = "associated-rule-id")]
|
|
pub associated_rule_id: Option<MaybeString>,
|
|
pub disabled: Option<u8>,
|
|
pub target: String,
|
|
#[yaserde(rename = "local-port")]
|
|
pub local_port: i32,
|
|
pub source: Source,
|
|
pub destination: Destination,
|
|
pub updated: Updated,
|
|
pub created: Created,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct PoolOpts {
|
|
// No specific fields for this element, can be added as needed
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Updated {
|
|
pub username: String,
|
|
pub time: f64,
|
|
pub description: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Created {
|
|
pub username: String,
|
|
pub time: f64,
|
|
pub description: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
#[yaserde(rename = "OPNsense")]
|
|
pub struct OPNsenseXmlSection {
|
|
pub captiveportal: Option<CaptivePortal>,
|
|
pub cron: Option<Cron>,
|
|
#[yaserde(rename = "Netflow")]
|
|
pub netflow: Option<Netflow>,
|
|
#[yaserde(rename = "Firewall")]
|
|
pub firewall: Option<Firewall>,
|
|
#[yaserde(rename = "IDS")]
|
|
pub ids: Option<IDS>,
|
|
#[yaserde(rename = "IPsec")]
|
|
pub ipsec: Option<IPsec>,
|
|
#[yaserde(rename = "Interfaces")]
|
|
pub interfaces: Option<ConfigInterfaces>,
|
|
pub monit: Option<Monit>,
|
|
#[yaserde(rename = "OpenVPNExport")]
|
|
pub openvpn_export: Option<OpenVPNExport>,
|
|
pub proxy: Option<Proxy>,
|
|
#[yaserde(rename = "Syslog")]
|
|
pub syslog: Option<ConfigSyslog>,
|
|
#[yaserde(rename = "TrafficShaper")]
|
|
pub traffic_shaper: Option<RawXml>,
|
|
pub unboundplus: Option<RawXml>,
|
|
pub wireguard: Option<Wireguard>,
|
|
#[yaserde(rename = "Swanctl")]
|
|
pub swanctl: Swanctl,
|
|
#[yaserde(rename = "DynDNS")]
|
|
pub dyndns: DynDNS,
|
|
#[yaserde(rename = "OpenVPN")]
|
|
pub openvpn: ConfigOpenVPN,
|
|
#[yaserde(rename = "Gateways")]
|
|
pub gateways: ConfigGateways,
|
|
#[yaserde(rename = "HAProxy")]
|
|
pub haproxy: HAProxy,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
#[yaserde(rename = "IDS")]
|
|
pub struct IDS {
|
|
#[yaserde(attribute)]
|
|
version: String,
|
|
rules: MaybeString,
|
|
policies: MaybeString,
|
|
#[yaserde(rename = "userDefinedRules")]
|
|
user_defined_rules: MaybeString,
|
|
files: MaybeString,
|
|
#[yaserde(rename = "fileTags")]
|
|
file_tags: MaybeString,
|
|
general: IDSGeneral,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct IDSGeneral {
|
|
enabled: Option<u8>,
|
|
ips: Option<u8>,
|
|
promisc: Option<u8>,
|
|
interfaces: String,
|
|
homenet: String,
|
|
#[yaserde(rename = "defaultPacketSize")]
|
|
default_packet_size: MaybeString,
|
|
#[yaserde(rename = "UpdateCron")]
|
|
update_cron: MaybeString,
|
|
#[yaserde(rename = "AlertLogrotate")]
|
|
alert_logrotate: String,
|
|
#[yaserde(rename = "AlertSaveLogs")]
|
|
alert_save_logs: u8,
|
|
#[yaserde(rename = "MPMAlgo")]
|
|
mpm_algo: String,
|
|
detect: Detect,
|
|
syslog: Option<u8>,
|
|
syslog_eve: Option<u8>,
|
|
#[yaserde(rename = "LogPayload")]
|
|
log_payload: Option<u8>,
|
|
verbosity: MaybeString,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct Detect {
|
|
#[yaserde(rename = "Profile")]
|
|
profile: String,
|
|
toclient_groups: MaybeString,
|
|
toserver_groups: MaybeString,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct IPsec {
|
|
#[yaserde(attribute)]
|
|
version: String,
|
|
general: GeneralIpsec,
|
|
#[yaserde(rename = "keyPairs")]
|
|
key_pairs: MaybeString,
|
|
#[yaserde(rename = "preSharedKeys")]
|
|
pre_shared_keys: MaybeString,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct GeneralIpsec {
|
|
enabled: MaybeString,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
#[yaserde(rename = "Interfaces")]
|
|
pub struct ConfigInterfaces {
|
|
vxlans: Vxlan,
|
|
loopbacks: Loopback,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct Vxlan {
|
|
#[yaserde(attribute)]
|
|
version: String,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct Loopback {
|
|
#[yaserde(attribute)]
|
|
version: String,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
#[yaserde(rename = "monit")]
|
|
pub struct Monit {
|
|
#[yaserde(attribute)]
|
|
version: String,
|
|
general: GeneralMonit,
|
|
alert: Option<Alert>,
|
|
service: Vec<Service>,
|
|
test: Vec<Test>,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct GeneralMonit {
|
|
enabled: u8,
|
|
interval: u32,
|
|
startdelay: u32,
|
|
mailserver: String,
|
|
port: u16,
|
|
username: MaybeString,
|
|
password: MaybeString,
|
|
ssl: u8,
|
|
sslversion: String,
|
|
sslverify: u8,
|
|
logfile: String,
|
|
statefile: MaybeString,
|
|
#[yaserde(rename = "eventqueuePath")]
|
|
event_queue_path: MaybeString,
|
|
#[yaserde(rename = "eventqueueSlots")]
|
|
event_queue_slots: MaybeString,
|
|
#[yaserde(rename = "httpdEnabled")]
|
|
httpd_enabled: u8,
|
|
#[yaserde(rename = "httpdUsername")]
|
|
httpd_username: String,
|
|
#[yaserde(rename = "httpdPassword")]
|
|
httpd_password: String,
|
|
#[yaserde(rename = "httpdPort")]
|
|
httpd_port: u16,
|
|
#[yaserde(rename = "httpdAllow")]
|
|
httpd_allow: MaybeString,
|
|
#[yaserde(rename = "mmonitUrl")]
|
|
mmonit_url: MaybeString,
|
|
#[yaserde(rename = "mmonitTimeout")]
|
|
mmonit_timeout: u32,
|
|
#[yaserde(rename = "mmonitRegisterCredentials")]
|
|
mmonit_register_credentials: u8,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct Alert {
|
|
#[yaserde(attribute)]
|
|
uuid: String,
|
|
enabled: u8,
|
|
recipient: String,
|
|
noton: u8,
|
|
events: MaybeString,
|
|
format: MaybeString,
|
|
reminder: u32,
|
|
description: MaybeString,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct Service {
|
|
#[yaserde(attribute)]
|
|
uuid: String,
|
|
enabled: u8,
|
|
name: String,
|
|
description: MaybeString,
|
|
#[yaserde(rename = "type")]
|
|
r#type: String,
|
|
pidfile: MaybeString,
|
|
#[yaserde(rename = "match")]
|
|
r#match: MaybeString,
|
|
path: MaybeString,
|
|
timeout: u32,
|
|
starttimeout: u32,
|
|
address: MaybeString,
|
|
interface: MaybeString,
|
|
start: MaybeString,
|
|
stop: MaybeString,
|
|
tests: String,
|
|
depends: MaybeString,
|
|
polltime: MaybeString,
|
|
}
|
|
|
|
#[derive(Debug, YaSerialize, YaDeserialize, PartialEq)]
|
|
pub struct Test {
|
|
#[yaserde(attribute)]
|
|
uuid: String,
|
|
name: String,
|
|
#[yaserde(rename = "type")]
|
|
r#type: String,
|
|
condition: String,
|
|
action: String,
|
|
path: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct CaptivePortal {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "zones")]
|
|
pub zones: Option<Zones>,
|
|
#[yaserde(rename = "templates")]
|
|
pub templates: Option<Templates>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Cron {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "jobs")]
|
|
pub jobs: Option<Jobs>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Netflow {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "capture")]
|
|
pub capture: Option<Capture>,
|
|
#[yaserde(rename = "collect")]
|
|
pub collect: Option<Collect>,
|
|
#[yaserde(rename = "activeTimeout")]
|
|
pub active_timeout: Option<u64>,
|
|
#[yaserde(rename = "inactiveTimeout")]
|
|
pub inactive_timeout: Option<u64>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Capture {
|
|
#[yaserde(rename = "interfaces")]
|
|
pub interfaces: MaybeString,
|
|
#[yaserde(rename = "egress_only")]
|
|
pub egress_only: MaybeString,
|
|
#[yaserde(rename = "version")]
|
|
pub version: MaybeString,
|
|
#[yaserde(rename = "targets")]
|
|
pub targets: Option<Targets>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Collect {
|
|
#[yaserde(rename = "enable")]
|
|
pub enable: Option<u8>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Zones {
|
|
// Define fields for Zones, e.g.:
|
|
#[yaserde(rename = "zone")]
|
|
pub zones: Vec<Zone>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Zone {
|
|
#[yaserde(attribute)]
|
|
pub uuid: MaybeString,
|
|
#[yaserde(rename = "name")]
|
|
pub name: MaybeString,
|
|
// Add other fields as needed
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Templates {
|
|
// Define fields for Templates, e.g.:
|
|
#[yaserde(rename = "template")]
|
|
pub templates: Vec<Template>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Template {
|
|
#[yaserde(attribute)]
|
|
pub uuid: MaybeString,
|
|
#[yaserde(rename = "name")]
|
|
pub name: MaybeString,
|
|
// Add other fields as needed
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Jobs {
|
|
// Define fields for Jobs, e.g.:
|
|
#[yaserde(rename = "job")]
|
|
pub jobs: Vec<Job>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Job {
|
|
#[yaserde(attribute)]
|
|
pub uuid: MaybeString,
|
|
#[yaserde(rename = "name")]
|
|
pub name: MaybeString,
|
|
// Add other fields as needed
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Targets {
|
|
// Define fields for Targets, e.g.:
|
|
#[yaserde(rename = "target")]
|
|
pub targets: Vec<Target>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Target {
|
|
#[yaserde(attribute)]
|
|
pub uuid: MaybeString,
|
|
#[yaserde(rename = "name")]
|
|
pub name: MaybeString,
|
|
// Add other fields as needed
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Firewall {
|
|
#[yaserde(rename = "Lvtemplate")]
|
|
pub lv_template: Option<LvTemplate>,
|
|
#[yaserde(rename = "Category")]
|
|
pub category: Option<Category>,
|
|
#[yaserde(rename = "Alias")]
|
|
pub alias: Option<Alias>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct LvTemplate {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "templates")]
|
|
pub templates: Option<Templates>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Category {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "categories")]
|
|
pub categories: Option<Categories>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Categories {
|
|
#[yaserde(rename = "category")]
|
|
pub categories: Vec<CategoryItem>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct CategoryItem {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
#[yaserde(rename = "name")]
|
|
pub name: MaybeString,
|
|
#[yaserde(rename = "auto")]
|
|
pub auto: Option<u8>,
|
|
#[yaserde(rename = "color")]
|
|
pub color: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Alias {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "geoip")]
|
|
pub geoip: Option<GeoIP>,
|
|
#[yaserde(rename = "aliases")]
|
|
pub aliases: Option<Aliases>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct GeoIP {
|
|
#[yaserde(rename = "url")]
|
|
pub url: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Aliases {
|
|
#[yaserde(rename = "alias")]
|
|
pub aliases: Vec<AliasItem>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct AliasItem {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
pub enabled: String,
|
|
pub name: String,
|
|
#[yaserde(rename = "type")]
|
|
pub r#type: String,
|
|
pub proto: MaybeString,
|
|
pub interface: MaybeString,
|
|
pub counters: String,
|
|
pub updatefreq: MaybeString,
|
|
pub content: String,
|
|
pub categories: MaybeString,
|
|
pub description: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct OpenVPNExport {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub servers: Option<Servers>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Servers {}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
#[yaserde(rename = "proxy")]
|
|
pub struct Proxy {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub general: ConfigGeneral,
|
|
pub forward: Forward,
|
|
pub pac: Option<Pac>,
|
|
#[yaserde(rename = "error_pages")]
|
|
pub error_pages: ErrorPages,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct ConfigGeneral {
|
|
pub enabled: i32,
|
|
#[yaserde(rename = "error_pages")]
|
|
pub error_pages: String,
|
|
pub icpPort: MaybeString,
|
|
pub logging: Logging,
|
|
pub alternateDNSservers: MaybeString,
|
|
pub dnsV4First: i32,
|
|
pub forwardedForHandling: String,
|
|
pub uriWhitespaceHandling: String,
|
|
pub enablePinger: i32,
|
|
pub useViaHeader: i32,
|
|
pub suppressVersion: i32,
|
|
pub connecttimeout: MaybeString,
|
|
#[yaserde(rename = "VisibleEmail")]
|
|
pub visible_email: String,
|
|
#[yaserde(rename = "VisibleHostname")]
|
|
pub visible_hostname: MaybeString,
|
|
pub cache: Cache,
|
|
pub traffic: Traffic,
|
|
pub parentproxy: ParentProxy,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Logging {
|
|
pub enable: Enable,
|
|
pub ignoreLogACL: MaybeString,
|
|
pub target: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Enable {
|
|
pub accessLog: i32,
|
|
pub storeLog: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Cache {
|
|
pub local: LocalCache,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct LocalCache {
|
|
pub enabled: i32,
|
|
pub directory: String,
|
|
pub cache_mem: i32,
|
|
pub maximum_object_size: MaybeString,
|
|
pub maximum_object_size_in_memory: MaybeString,
|
|
pub memory_cache_mode: String,
|
|
pub size: i32,
|
|
pub l1: i32,
|
|
pub l2: i32,
|
|
pub cache_linux_packages: i32,
|
|
pub cache_windows_updates: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Traffic {
|
|
pub enabled: i32,
|
|
#[yaserde(rename = "maxDownloadSize")]
|
|
pub max_download_size: i32,
|
|
#[yaserde(rename = "maxUploadSize")]
|
|
pub max_upload_size: i32,
|
|
#[yaserde(rename = "OverallBandwidthTrotteling")]
|
|
pub overall_bandwidth_trotteling: i32,
|
|
#[yaserde(rename = "perHostTrotteling")]
|
|
pub per_host_trotteling: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct ParentProxy {
|
|
pub enabled: i32,
|
|
pub host: MaybeString,
|
|
pub enableauth: i32,
|
|
pub user: MaybeString,
|
|
pub password: MaybeString,
|
|
pub port: MaybeString,
|
|
pub localdomains: MaybeString,
|
|
pub localips: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Forward {
|
|
pub interfaces: String,
|
|
pub port: i32,
|
|
pub sslbumpport: i32,
|
|
pub sslbump: i32,
|
|
pub sslurlonly: i32,
|
|
pub sslcertificate: MaybeString,
|
|
pub sslnobumpsites: MaybeString,
|
|
pub ssl_crtd_storage_max_size: i32,
|
|
pub sslcrtd_children: i32,
|
|
pub snmp_enable: i32,
|
|
pub snmp_port: i32,
|
|
pub snmp_password: String,
|
|
#[yaserde(rename = "ftpInterfaces")]
|
|
pub ftp_interfaces: MaybeString,
|
|
#[yaserde(rename = "ftpPort")]
|
|
pub ftp_port: i32,
|
|
#[yaserde(rename = "ftpTransparentMode")]
|
|
pub ftp_transparent_mode: i32,
|
|
#[yaserde(rename = "addACLforInterfaceSubnets")]
|
|
pub add_acl_for_interface_subnets: i32,
|
|
#[yaserde(rename = "transparentMode")]
|
|
pub transparent_mode: i32,
|
|
pub acl: Acl,
|
|
pub icap: Icap,
|
|
pub authentication: Authentication,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Acl {
|
|
#[yaserde(rename = "allowedSubnets")]
|
|
pub allowed_subnets: MaybeString,
|
|
pub unrestricted: MaybeString,
|
|
#[yaserde(rename = "bannedHosts")]
|
|
pub banned_hosts: MaybeString,
|
|
#[yaserde(rename = "whiteList")]
|
|
pub white_list: MaybeString,
|
|
#[yaserde(rename = "blackList")]
|
|
pub black_list: MaybeString,
|
|
pub browser: MaybeString,
|
|
#[yaserde(rename = "mimeType")]
|
|
pub mime_type: MaybeString,
|
|
pub google_apps: MaybeString,
|
|
pub youtube: MaybeString,
|
|
#[yaserde(rename = "safePorts")]
|
|
pub safe_ports: String,
|
|
#[yaserde(rename = "sslPorts")]
|
|
pub ssl_ports: String,
|
|
#[yaserde(rename = "remoteACLs")]
|
|
pub remote_acls: RemoteAcls,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct RemoteAcls {
|
|
pub blacklists: MaybeString,
|
|
#[yaserde(rename = "UpdateCron")]
|
|
pub update_cron: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Icap {
|
|
pub enable: i32,
|
|
#[yaserde(rename = "RequestURL")]
|
|
pub request_url: String,
|
|
#[yaserde(rename = "ResponseURL")]
|
|
pub response_url: String,
|
|
#[yaserde(rename = "SendClientIP")]
|
|
pub send_client_ip: i32,
|
|
#[yaserde(rename = "SendUsername")]
|
|
pub send_username: i32,
|
|
#[yaserde(rename = "EncodeUsername")]
|
|
pub encode_username: i32,
|
|
#[yaserde(rename = "UsernameHeader")]
|
|
pub username_header: String,
|
|
#[yaserde(rename = "EnablePreview")]
|
|
pub enable_preview: i32,
|
|
#[yaserde(rename = "PreviewSize")]
|
|
pub preview_size: i32,
|
|
#[yaserde(rename = "OptionsTTL")]
|
|
pub options_ttl: i32,
|
|
pub exclude: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Authentication {
|
|
pub method: MaybeString,
|
|
#[yaserde(rename = "authEnforceGroup")]
|
|
pub auth_enforce_group: MaybeString,
|
|
pub realm: String,
|
|
pub credentialsttl: i32, // This field is already in snake_case
|
|
pub children: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Pac {}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct ErrorPages {
|
|
pub template: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct ConfigSyslog {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub general: SyslogGeneral,
|
|
pub destinations: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct SyslogGeneral {
|
|
pub enabled: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct UnboundPlus {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub general: UnboundGeneral,
|
|
pub advanced: Advanced,
|
|
pub acls: Acls,
|
|
pub dnsbl: Dnsbl,
|
|
pub forwarding: Forwarding,
|
|
pub dots: MaybeString,
|
|
pub hosts: Hosts,
|
|
pub aliases: MaybeString,
|
|
pub domains: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct UnboundGeneral {
|
|
pub enabled: i32,
|
|
pub port: i32,
|
|
pub stats: MaybeString,
|
|
pub active_interface: MaybeString,
|
|
pub dnssec: MaybeString,
|
|
pub dns64: MaybeString,
|
|
pub dns64prefix: MaybeString,
|
|
pub noarecords: MaybeString,
|
|
pub regdhcp: i32,
|
|
pub regdhcpdomain: MaybeString,
|
|
pub regdhcpstatic: i32,
|
|
pub noreglladdr6: MaybeString,
|
|
pub noregrecords: MaybeString,
|
|
pub txtsupport: MaybeString,
|
|
pub cacheflush: MaybeString,
|
|
pub local_zone_type: String,
|
|
pub outgoing_interface: MaybeString,
|
|
pub enable_wpad: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Advanced {
|
|
pub hideidentity: i32,
|
|
pub hideversion: i32,
|
|
pub prefetch: i32,
|
|
pub prefetchkey: i32,
|
|
pub dnssecstripped: i32,
|
|
pub serveexpired: i32,
|
|
pub serveexpiredreplyttl: MaybeString,
|
|
pub serveexpiredttl: MaybeString,
|
|
pub serveexpiredttlreset: i32,
|
|
pub serveexpiredclienttimeout: MaybeString,
|
|
pub qnameminstrict: i32,
|
|
pub extendedstatistics: i32,
|
|
pub logqueries: i32,
|
|
pub logreplies: i32,
|
|
pub logtagqueryreply: i32,
|
|
pub logservfail: MaybeString,
|
|
pub loglocalactions: MaybeString,
|
|
pub logverbosity: i32,
|
|
pub valloglevel: i32,
|
|
pub privatedomain: MaybeString,
|
|
pub privateaddress: MaybeString,
|
|
pub insecuredomain: MaybeString,
|
|
pub msgcachesize: MaybeString,
|
|
pub rrsetcachesize: MaybeString,
|
|
pub outgoingnumtcp: MaybeString,
|
|
pub incomingnumtcp: MaybeString,
|
|
pub numqueriesperthread: MaybeString,
|
|
pub outgoingrange: MaybeString,
|
|
pub jostletimeout: MaybeString,
|
|
pub cachemaxttl: MaybeString,
|
|
pub cachemaxnegativettl: MaybeString,
|
|
pub cacheminttl: MaybeString,
|
|
pub infrahostttl: MaybeString,
|
|
pub infrakeepprobing: MaybeString,
|
|
pub infracachenumhosts: MaybeString,
|
|
pub unwantedreplythreshold: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Acls {
|
|
#[yaserde(rename = "default_action")]
|
|
pub default_action: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Dnsbl {
|
|
pub enabled: i32,
|
|
pub safesearch: MaybeString,
|
|
#[yaserde(rename = "type")]
|
|
pub r#type: MaybeString,
|
|
pub lists: MaybeString,
|
|
pub whitelists: MaybeString,
|
|
pub blocklists: MaybeString,
|
|
pub wildcards: MaybeString,
|
|
pub address: MaybeString,
|
|
pub nxdomain: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Forwarding {
|
|
pub enabled: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Hosts {
|
|
#[yaserde(rename = "host")]
|
|
pub hosts: Vec<Host>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Host {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
pub enabled: i32,
|
|
pub hostname: String,
|
|
pub domain: String,
|
|
pub rr: String,
|
|
pub mxprio: MaybeString,
|
|
pub mx: MaybeString,
|
|
pub server: String,
|
|
pub description: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Wireguard {
|
|
pub general: WireguardGeneral,
|
|
pub server: WireguardServer,
|
|
pub client: WireguardClient,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct WireguardGeneral {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub enabled: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct WireguardServer {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub servers: WireguardServerList,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct WireguardServerList {
|
|
pub server: Vec<WireguardServerItem>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct WireguardServerItem {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
pub enabled: i32,
|
|
pub name: String,
|
|
pub instance: i32,
|
|
pub pubkey: String,
|
|
pub privkey: String,
|
|
pub port: i32,
|
|
pub mtu: MaybeString,
|
|
pub dns: MaybeString,
|
|
pub tunneladdress: String,
|
|
pub disableroutes: i32,
|
|
pub gateway: MaybeString,
|
|
pub carp_depend_on: MaybeString,
|
|
pub peers: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct WireguardClient {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub clients: WireguardClientList,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct WireguardClientList {
|
|
pub client: Vec<WireguardClientItem>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct WireguardClientItem {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
pub enabled: i32,
|
|
pub name: String,
|
|
pub pubkey: String,
|
|
pub psk: MaybeString,
|
|
pub tunneladdress: String,
|
|
pub serveraddress: MaybeString,
|
|
pub serverport: MaybeString,
|
|
pub keepalive: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Swanctl {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "Connections")]
|
|
pub connections: MaybeString,
|
|
pub locals: MaybeString,
|
|
pub remotes: MaybeString,
|
|
pub children: MaybeString,
|
|
#[yaserde(rename = "Pools")]
|
|
pub pools: MaybeString,
|
|
#[yaserde(rename = "VTIs")]
|
|
pub vtis: MaybeString,
|
|
#[yaserde(rename = "SPDs")]
|
|
pub spds: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
#[yaserde(rename = "DynDNS")]
|
|
pub struct DynDNS {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub general: DynDNSGeneral,
|
|
pub accounts: Accounts,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct DynDNSGeneral {
|
|
pub enabled: i32,
|
|
pub verbose: i32,
|
|
pub allowipv6: i32,
|
|
pub daemon_delay: i32,
|
|
pub backend: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Accounts {
|
|
#[yaserde(rename = "account")]
|
|
pub account: Account,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Account {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
pub enabled: i32,
|
|
pub service: String,
|
|
pub protocol: MaybeString,
|
|
pub server: MaybeString,
|
|
pub username: String,
|
|
pub password: String,
|
|
#[yaserde(rename = "resourceId")]
|
|
pub resource_id: MaybeString,
|
|
pub hostnames: String,
|
|
pub wildcard: i32,
|
|
pub zone: MaybeString,
|
|
pub checkip: String,
|
|
#[yaserde(rename = "checkip_timeout")]
|
|
pub checkip_timeout: i32,
|
|
#[yaserde(rename = "force_ssl")]
|
|
pub force_ssl: i32,
|
|
pub ttl: i32,
|
|
pub interface: String,
|
|
pub description: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct ConfigOpenVPN {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "Overwrites")]
|
|
pub Overwrites: MaybeString,
|
|
#[yaserde(rename = "Instances")]
|
|
pub Instances: MaybeString,
|
|
#[yaserde(rename = "StaticKeys")]
|
|
pub StaticKeys: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct ConfigGateways {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
#[yaserde(rename = "HAProxy")]
|
|
pub struct HAProxy {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub general: HaProxyGeneral,
|
|
pub frontends: HAProxyFrontends,
|
|
pub backends: HAProxyBackends,
|
|
pub servers: HAProxyServers,
|
|
pub healthchecks: HAProxyHealthChecks,
|
|
pub acls: MaybeString,
|
|
pub actions: MaybeString,
|
|
pub luas: MaybeString,
|
|
pub fcgis: MaybeString,
|
|
pub errorfiles: MaybeString,
|
|
pub mapfiles: MaybeString,
|
|
pub groups: MaybeString,
|
|
pub users: MaybeString,
|
|
pub cpus: MaybeString,
|
|
pub resolvers: MaybeString,
|
|
pub mailers: MaybeString,
|
|
pub maintenance: Maintenance,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Maintenance {
|
|
#[yaserde(rename = "cronjobs")]
|
|
pub cronjobs: CronJobs,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct CronJobs {
|
|
#[yaserde(rename = "syncCerts")]
|
|
pub sync_certs: u32,
|
|
#[yaserde(rename = "syncCertsCron")]
|
|
pub sync_certs_cron: MaybeString,
|
|
#[yaserde(rename = "updateOcsp")]
|
|
pub update_ocsp: u32,
|
|
#[yaserde(rename = "updateOcspCron")]
|
|
pub update_ocsp_cron: MaybeString,
|
|
#[yaserde(rename = "reloadService")]
|
|
pub reload_service: u32,
|
|
#[yaserde(rename = "reloadServiceCron")]
|
|
pub reload_service_cron: MaybeString,
|
|
#[yaserde(rename = "restartService")]
|
|
pub restart_service: u32,
|
|
#[yaserde(rename = "restartServiceCron")]
|
|
pub restart_service_cron: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HaProxyGeneral {
|
|
pub enabled: i32,
|
|
#[yaserde(rename = "gracefulStop")]
|
|
pub graceful_stop: i32,
|
|
#[yaserde(rename = "hardStopAfter")]
|
|
pub hard_stop_after: String,
|
|
#[yaserde(rename = "closeSpreadTime")]
|
|
pub close_spread_time: MaybeString,
|
|
#[yaserde(rename = "seamlessReload")]
|
|
pub seamless_reload: i32,
|
|
#[yaserde(rename = "storeOcsp")]
|
|
pub store_ocsp: i32,
|
|
#[yaserde(rename = "showIntro")]
|
|
pub show_intro: i32,
|
|
pub peers: Peers,
|
|
pub tuning: Tuning,
|
|
pub defaults: HaProxyDefaults,
|
|
pub logging: HaProxyLogging,
|
|
pub stats: Stats,
|
|
pub cache: HaProxyCache,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Peers {
|
|
pub enabled: i32,
|
|
pub name1: MaybeString,
|
|
pub listen1: MaybeString,
|
|
pub port1: i32,
|
|
pub name2: MaybeString,
|
|
pub listen2: MaybeString,
|
|
pub port2: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Tuning {
|
|
pub root: i32,
|
|
#[yaserde(rename = "maxConnections")]
|
|
pub max_connections: MaybeString,
|
|
pub nbthread: i32,
|
|
#[yaserde(rename = "sslServerVerify")]
|
|
pub ssl_server_verify: String,
|
|
#[yaserde(rename = "maxDHSize")]
|
|
pub max_dh_size: i32,
|
|
#[yaserde(rename = "bufferSize")]
|
|
pub buffer_size: i32,
|
|
#[yaserde(rename = "spreadChecks")]
|
|
pub spread_checks: i32,
|
|
#[yaserde(rename = "bogusProxyEnabled")]
|
|
pub bogus_proxy_enabled: i32,
|
|
#[yaserde(rename = "luaMaxMem")]
|
|
pub lua_max_mem: i32,
|
|
#[yaserde(rename = "customOptions")]
|
|
pub custom_options: MaybeString,
|
|
#[yaserde(rename = "ssl_defaultsEnabled")]
|
|
pub ssl_defaults_enabled: i32,
|
|
#[yaserde(rename = "ssl_bindOptions")]
|
|
pub ssl_bind_options: String,
|
|
#[yaserde(rename = "ssl_minVersion")]
|
|
pub ssl_min_version: String,
|
|
#[yaserde(rename = "ssl_maxVersion")]
|
|
pub ssl_max_version: MaybeString,
|
|
#[yaserde(rename = "ssl_cipherList")]
|
|
pub ssl_cipher_list: String,
|
|
#[yaserde(rename = "ssl_cipherSuites")]
|
|
pub ssl_cipher_suites: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HaProxyDefaults {
|
|
#[yaserde(rename = "maxConnections")]
|
|
pub max_connections: MaybeString,
|
|
#[yaserde(rename = "maxConnectionsServers")]
|
|
pub max_connections_servers: MaybeString,
|
|
#[yaserde(rename = "timeoutClient")]
|
|
pub timeout_client: String,
|
|
#[yaserde(rename = "timeoutConnect")]
|
|
pub timeout_connect: String,
|
|
#[yaserde(rename = "timeoutCheck")]
|
|
pub timeout_check: MaybeString,
|
|
#[yaserde(rename = "timeoutServer")]
|
|
pub timeout_server: String,
|
|
pub retries: i32,
|
|
pub redispatch: String,
|
|
pub init_addr: String,
|
|
#[yaserde(rename = "customOptions")]
|
|
pub custom_options: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HaProxyLogging {
|
|
pub host: String,
|
|
pub facility: String,
|
|
pub level: String,
|
|
pub length: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Stats {
|
|
pub enabled: i32,
|
|
pub port: i32,
|
|
#[yaserde(rename = "remoteEnabled")]
|
|
pub remote_enabled: i32,
|
|
#[yaserde(rename = "remoteBind")]
|
|
pub remote_bind: MaybeString,
|
|
#[yaserde(rename = "authEnabled")]
|
|
pub auth_enabled: i32,
|
|
#[yaserde(rename = "users")]
|
|
pub users: MaybeString,
|
|
#[yaserde(rename = "allowedUsers")]
|
|
pub allowed_users: MaybeString,
|
|
#[yaserde(rename = "allowedGroups")]
|
|
pub allowed_groups: MaybeString,
|
|
#[yaserde(rename = "customOptions")]
|
|
pub custom_options: MaybeString,
|
|
pub prometheus_enabled: i32,
|
|
pub prometheus_bind: String,
|
|
pub prometheus_path: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HaProxyCache {
|
|
pub enabled: i32,
|
|
#[yaserde(rename = "totalMaxSize")]
|
|
pub total_max_size: i32,
|
|
#[yaserde(rename = "maxAge")]
|
|
pub max_age: i32,
|
|
#[yaserde(rename = "maxObjectSize")]
|
|
pub max_object_size: MaybeString,
|
|
#[yaserde(rename = "processVary")]
|
|
pub process_vary: i32,
|
|
#[yaserde(rename = "maxSecondaryEntries")]
|
|
pub max_secondary_entries: i32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HAProxyFrontends {
|
|
pub frontend: Vec<Frontend>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Frontend {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
pub id: String,
|
|
pub enabled: i32,
|
|
pub name: String,
|
|
pub description: String,
|
|
pub bind: String,
|
|
#[yaserde(rename = "bindOptions")]
|
|
pub bind_options: MaybeString,
|
|
pub mode: String,
|
|
#[yaserde(rename = "defaultBackend")]
|
|
pub default_backend: String,
|
|
pub ssl_enabled: i32,
|
|
pub ssl_certificates: MaybeString,
|
|
pub ssl_default_certificate: MaybeString,
|
|
#[yaserde(rename = "ssl_customOptions")]
|
|
pub ssl_custom_options: MaybeString,
|
|
#[yaserde(rename = "ssl_advancedEnabled")]
|
|
pub ssl_advanced_enabled: i32,
|
|
#[yaserde(rename = "ssl_bindOptions")]
|
|
pub ssl_bind_options: String,
|
|
#[yaserde(rename = "ssl_minVersion")]
|
|
pub ssl_min_version: String,
|
|
#[yaserde(rename = "ssl_maxVersion")]
|
|
pub ssl_max_version: MaybeString,
|
|
#[yaserde(rename = "ssl_cipherList")]
|
|
pub ssl_cipher_list: String,
|
|
#[yaserde(rename = "ssl_cipherSuites")]
|
|
pub ssl_cipher_suites: String,
|
|
#[yaserde(rename = "ssl_hstsEnabled")]
|
|
pub ssl_hsts_enabled: i32,
|
|
#[yaserde(rename = "ssl_hstsIncludeSubDomains")]
|
|
pub ssl_hsts_include_sub_domains: i32,
|
|
#[yaserde(rename = "ssl_hstsPreload")]
|
|
pub ssl_hsts_preload: i32,
|
|
#[yaserde(rename = "ssl_hstsMaxAge")]
|
|
pub ssl_hsts_max_age: i32,
|
|
#[yaserde(rename = "ssl_clientAuthEnabled")]
|
|
pub ssl_client_auth_enabled: i32,
|
|
#[yaserde(rename = "ssl_clientAuthVerify")]
|
|
pub ssl_client_auth_verify: String,
|
|
#[yaserde(rename = "ssl_clientAuthCAs")]
|
|
pub ssl_client_auth_cas: MaybeString,
|
|
#[yaserde(rename = "ssl_clientAuthCRLs")]
|
|
pub ssl_client_auth_cr_ls: MaybeString,
|
|
#[yaserde(rename = "basicAuthEnabled")]
|
|
pub basic_auth_enabled: i32,
|
|
#[yaserde(rename = "basicAuthUsers")]
|
|
pub basic_auth_users: MaybeString,
|
|
#[yaserde(rename = "basicAuthGroups")]
|
|
pub basic_auth_groups: MaybeString,
|
|
#[yaserde(rename = "tuning_maxConnections")]
|
|
pub tuning_max_connections: MaybeString,
|
|
#[yaserde(rename = "tuning_timeoutClient")]
|
|
pub tuning_timeout_client: MaybeString,
|
|
#[yaserde(rename = "tuning_timeoutHttpReq")]
|
|
pub tuning_timeout_http_req: MaybeString,
|
|
#[yaserde(rename = "tuning_timeoutHttpKeepAlive")]
|
|
pub tuning_timeout_http_keep_alive: MaybeString,
|
|
#[yaserde(rename = "linkedCpuAffinityRules")]
|
|
pub linked_cpu_affinity_rules: MaybeString,
|
|
pub tuning_shards: MaybeString,
|
|
#[yaserde(rename = "logging_dontLogNull")]
|
|
pub logging_dont_log_null: i32,
|
|
#[yaserde(rename = "logging_dontLogNormal")]
|
|
pub logging_dont_log_normal: i32,
|
|
#[yaserde(rename = "logging_logSeparateErrors")]
|
|
pub logging_log_separate_errors: i32,
|
|
#[yaserde(rename = "logging_detailedLog")]
|
|
pub logging_detailed_log: i32,
|
|
#[yaserde(rename = "logging_socketStats")]
|
|
pub logging_socket_stats: i32,
|
|
pub stickiness_pattern: MaybeString,
|
|
#[yaserde(rename = "stickiness_dataTypes")]
|
|
pub stickiness_data_types: MaybeString,
|
|
pub stickiness_expire: String,
|
|
pub stickiness_size: String,
|
|
pub stickiness_counter: i32,
|
|
pub stickiness_counter_key: String,
|
|
pub stickiness_length: MaybeString,
|
|
#[yaserde(rename = "stickiness_connRatePeriod")]
|
|
pub stickiness_conn_rate_period: String,
|
|
#[yaserde(rename = "stickiness_sessRatePeriod")]
|
|
pub stickiness_sess_rate_period: String,
|
|
#[yaserde(rename = "stickiness_httpReqRatePeriod")]
|
|
pub stickiness_http_req_rate_period: String,
|
|
#[yaserde(rename = "stickiness_httpErrRatePeriod")]
|
|
pub stickiness_http_err_rate_period: String,
|
|
#[yaserde(rename = "stickiness_bytesInRatePeriod")]
|
|
pub stickiness_bytes_in_rate_period: String,
|
|
#[yaserde(rename = "stickiness_bytesOutRatePeriod")]
|
|
pub stickiness_bytes_out_rate_period: String,
|
|
#[yaserde(rename = "http2Enabled")]
|
|
pub http2_enabled: i32,
|
|
#[yaserde(rename = "http2Enabled_nontls")]
|
|
pub http2_enabled_nontls: i32,
|
|
pub advertised_protocols: String,
|
|
#[yaserde(rename = "forwardFor")]
|
|
pub forward_for: i32,
|
|
pub prometheus_enabled: i32,
|
|
pub prometheus_path: String,
|
|
#[yaserde(rename = "connectionBehaviour")]
|
|
pub connection_behaviour: String,
|
|
#[yaserde(rename = "customOptions")]
|
|
pub custom_options: MaybeString,
|
|
#[yaserde(rename = "linkedActions")]
|
|
pub linked_actions: MaybeString,
|
|
#[yaserde(rename = "linkedErrorfiles")]
|
|
pub linked_error_files: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HAProxyBackends {
|
|
#[yaserde(rename = "backend")]
|
|
pub backends: Vec<Backend>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Backend {
|
|
#[yaserde(attribute, rename = "uuid")]
|
|
pub uuid: String,
|
|
#[yaserde(rename = "id")]
|
|
pub id: String,
|
|
#[yaserde(rename = "enabled")]
|
|
pub enabled: u8,
|
|
#[yaserde(rename = "name")]
|
|
pub name: String,
|
|
#[yaserde(rename = "description")]
|
|
pub description: MaybeString,
|
|
#[yaserde(rename = "mode")]
|
|
pub mode: String,
|
|
#[yaserde(rename = "algorithm")]
|
|
pub algorithm: String,
|
|
#[yaserde(rename = "random_draws")]
|
|
pub random_draws: Option<u32>,
|
|
#[yaserde(rename = "proxyProtocol")]
|
|
pub proxy_protocol: MaybeString,
|
|
#[yaserde(rename = "linkedServers")]
|
|
pub linked_servers: MaybeString,
|
|
#[yaserde(rename = "linkedFcgi")]
|
|
pub linked_fcgi: MaybeString,
|
|
#[yaserde(rename = "linkedResolver")]
|
|
pub linked_resolver: MaybeString,
|
|
#[yaserde(rename = "resolverOpts")]
|
|
pub resolver_opts: MaybeString,
|
|
#[yaserde(rename = "resolvePrefer")]
|
|
pub resolve_prefer: MaybeString,
|
|
#[yaserde(rename = "source")]
|
|
pub source: MaybeString,
|
|
#[yaserde(rename = "healthCheckEnabled")]
|
|
pub health_check_enabled: u8,
|
|
#[yaserde(rename = "healthCheck")]
|
|
pub health_check: MaybeString,
|
|
#[yaserde(rename = "healthCheckLogStatus")]
|
|
pub health_check_log_status: u8,
|
|
#[yaserde(rename = "checkInterval")]
|
|
pub check_interval: MaybeString,
|
|
#[yaserde(rename = "checkDownInterval")]
|
|
pub check_down_interval: MaybeString,
|
|
#[yaserde(rename = "healthCheckFall")]
|
|
pub health_check_fall: MaybeString,
|
|
#[yaserde(rename = "healthCheckRise")]
|
|
pub health_check_rise: MaybeString,
|
|
#[yaserde(rename = "linkedMailer")]
|
|
pub linked_mailer: MaybeString,
|
|
#[yaserde(rename = "http2Enabled")]
|
|
pub http2_enabled: u8,
|
|
#[yaserde(rename = "http2Enabled_nontls")]
|
|
pub http2_enabled_nontls: u8,
|
|
#[yaserde(rename = "ba_advertised_protocols")]
|
|
pub ba_advertised_protocols: String,
|
|
#[yaserde(rename = "persistence")]
|
|
pub persistence: String,
|
|
#[yaserde(rename = "persistence_cookiemode")]
|
|
pub persistence_cookiemode: String,
|
|
#[yaserde(rename = "persistence_cookiename")]
|
|
pub persistence_cookiename: MaybeString,
|
|
#[yaserde(rename = "persistence_stripquotes")]
|
|
pub persistence_stripquotes: u8,
|
|
#[yaserde(rename = "stickiness_pattern")]
|
|
pub stickiness_pattern: String,
|
|
#[yaserde(rename = "stickiness_dataTypes")]
|
|
pub stickiness_data_types: MaybeString,
|
|
#[yaserde(rename = "stickiness_expire")]
|
|
pub stickiness_expire: String,
|
|
#[yaserde(rename = "stickiness_size")]
|
|
pub stickiness_size: String,
|
|
#[yaserde(rename = "stickiness_cookiename")]
|
|
pub stickiness_cookiename: MaybeString,
|
|
#[yaserde(rename = "stickiness_cookielength")]
|
|
pub stickiness_cookielength: MaybeString,
|
|
#[yaserde(rename = "stickiness_connRatePeriod")]
|
|
pub stickiness_conn_rate_period: String,
|
|
#[yaserde(rename = "stickiness_sessRatePeriod")]
|
|
pub stickiness_sess_rate_period: String,
|
|
#[yaserde(rename = "stickiness_httpReqRatePeriod")]
|
|
pub stickiness_http_req_rate_period: String,
|
|
#[yaserde(rename = "stickiness_httpErrRatePeriod")]
|
|
pub stickiness_http_err_rate_period: String,
|
|
#[yaserde(rename = "stickiness_bytesInRatePeriod")]
|
|
pub stickiness_bytes_in_rate_period: String,
|
|
#[yaserde(rename = "stickiness_bytesOutRatePeriod")]
|
|
pub stickiness_bytes_out_rate_period: String,
|
|
#[yaserde(rename = "basicAuthEnabled")]
|
|
pub basic_auth_enabled: u8,
|
|
#[yaserde(rename = "basicAuthUsers")]
|
|
pub basic_auth_users: MaybeString,
|
|
#[yaserde(rename = "basicAuthGroups")]
|
|
pub basic_auth_groups: MaybeString,
|
|
#[yaserde(rename = "tuning_timeoutConnect")]
|
|
pub tuning_timeout_connect: MaybeString,
|
|
#[yaserde(rename = "tuning_timeoutCheck")]
|
|
pub tuning_timeout_check: MaybeString,
|
|
#[yaserde(rename = "tuning_timeoutServer")]
|
|
pub tuning_timeout_server: MaybeString,
|
|
#[yaserde(rename = "tuning_retries")]
|
|
pub tuning_retries: MaybeString,
|
|
#[yaserde(rename = "customOptions")]
|
|
pub custom_options: MaybeString,
|
|
#[yaserde(rename = "tuning_defaultserver")]
|
|
pub tuning_defaultserver: MaybeString,
|
|
#[yaserde(rename = "tuning_noport")]
|
|
pub tuning_noport: u8,
|
|
#[yaserde(rename = "tuning_httpreuse")]
|
|
pub tuning_httpreuse: MaybeString,
|
|
#[yaserde(rename = "tuning_caching")]
|
|
pub tuning_caching: u8,
|
|
#[yaserde(rename = "linkedActions")]
|
|
pub linked_actions: MaybeString,
|
|
#[yaserde(rename = "linkedErrorfiles")]
|
|
pub linked_errorfiles: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HAProxyServers {
|
|
#[yaserde(rename = "server")]
|
|
pub servers: Vec<HAProxyServer>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HAProxyServer {
|
|
#[yaserde(attribute, rename = "uuid")]
|
|
pub uuid: String,
|
|
pub id: String,
|
|
pub enabled: u8,
|
|
pub name: String,
|
|
pub description: MaybeString,
|
|
pub address: String,
|
|
pub port: u16,
|
|
pub checkport: MaybeString,
|
|
pub mode: String,
|
|
pub multiplexer_protocol: String,
|
|
#[yaserde(rename = "type")]
|
|
pub server_type: String,
|
|
#[yaserde(rename = "serviceName")]
|
|
pub service_name: MaybeString,
|
|
pub number: MaybeString,
|
|
#[yaserde(rename = "linkedResolver")]
|
|
pub linked_resolver: MaybeString,
|
|
#[yaserde(rename = "resolverOpts")]
|
|
pub resolver_opts: MaybeString,
|
|
#[yaserde(rename = "resolvePrefer")]
|
|
pub resolve_prefer: MaybeString,
|
|
pub ssl: u8,
|
|
#[yaserde(rename = "sslSNI")]
|
|
pub ssl_sni: MaybeString,
|
|
#[yaserde(rename = "sslVerify")]
|
|
pub ssl_verify: u8,
|
|
#[yaserde(rename = "sslCA")]
|
|
pub ssl_ca: MaybeString,
|
|
#[yaserde(rename = "sslCRL")]
|
|
pub ssl_crl: MaybeString,
|
|
#[yaserde(rename = "sslClientCertificate")]
|
|
pub ssl_client_certificate: MaybeString,
|
|
#[yaserde(rename = "maxConnections")]
|
|
pub max_connections: MaybeString,
|
|
pub weight: u32,
|
|
#[yaserde(rename = "checkInterval")]
|
|
pub check_interval: MaybeString,
|
|
#[yaserde(rename = "checkDownInterval")]
|
|
pub check_down_interval: MaybeString,
|
|
pub source: MaybeString,
|
|
pub advanced: MaybeString,
|
|
#[yaserde(rename = "unix_socket")]
|
|
pub unix_socket: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HAProxyHealthChecks {
|
|
#[yaserde(rename = "healthcheck")]
|
|
pub healthchecks: Vec<HAProxyHealthCheck>,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct HAProxyHealthCheck {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
pub name: String,
|
|
pub description: MaybeString,
|
|
#[yaserde(rename = "type")]
|
|
pub health_check_type: String,
|
|
pub interval: String,
|
|
pub ssl: String,
|
|
#[yaserde(rename = "sslSNI")]
|
|
pub ssl_sni: MaybeString,
|
|
pub force_ssl: u8,
|
|
pub checkport: MaybeString,
|
|
pub http_method: String,
|
|
pub http_uri: String,
|
|
pub http_version: MaybeString,
|
|
#[yaserde(rename = "http_host")]
|
|
pub http_host: MaybeString,
|
|
#[yaserde(rename = "http_expressionEnabled")]
|
|
pub http_expression_enabled: Option<u8>,
|
|
pub http_expression: MaybeString,
|
|
pub http_negate: MaybeString,
|
|
pub http_value: MaybeString,
|
|
pub tcp_enabled: MaybeString,
|
|
#[yaserde(rename = "tcp_sendValue")]
|
|
pub tcp_send_value: MaybeString,
|
|
#[yaserde(rename = "tcp_matchType")]
|
|
pub tcp_match_type: MaybeString,
|
|
pub tcp_negate: MaybeString,
|
|
#[yaserde(rename = "tcp_matchValue")]
|
|
pub tcp_match_value: MaybeString,
|
|
pub agent_port: MaybeString,
|
|
pub mysql_user: MaybeString,
|
|
pub mysql_post41: MaybeString,
|
|
pub pgsql_user: MaybeString,
|
|
pub smtp_domain: MaybeString,
|
|
pub esmtp_domain: MaybeString,
|
|
#[yaserde(rename = "agentPort")]
|
|
pub agent_port_uppercase: MaybeString,
|
|
#[yaserde(rename = "dbUser")]
|
|
pub db_user: MaybeString,
|
|
#[yaserde(rename = "smtpDomain")]
|
|
pub smtp_domain_uppercase: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct StaticRoutes {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "route")]
|
|
pub route: MaybeString, // Assuming it can be empty, use Option
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Ca {} // Empty struct for <ca/>
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Gateways {
|
|
#[yaserde(rename = "gateway_item")]
|
|
pub gateway_item: MaybeString, // Assuming it can be empty, use Option
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Cert {
|
|
#[yaserde(rename = "refid")]
|
|
pub refid: String,
|
|
#[yaserde(rename = "descr")]
|
|
pub descr: String,
|
|
#[yaserde(rename = "crt")]
|
|
pub crt: String,
|
|
#[yaserde(rename = "prv")]
|
|
pub prv: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct DhcpDv6 {} // Empty struct for <dhcpdv6/>
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct VirtualIp {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
#[yaserde(rename = "vip")]
|
|
pub vip: Vip,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Vip {
|
|
#[yaserde(attribute)]
|
|
pub uuid: String,
|
|
pub interface: String,
|
|
pub mode: String,
|
|
pub subnet: String,
|
|
pub subnet_bits: u32,
|
|
pub gateway: String,
|
|
pub noexpand: u32,
|
|
pub nobind: u32,
|
|
pub password: MaybeString,
|
|
pub vhid: MaybeString,
|
|
pub advbase: u32,
|
|
pub advskew: u32,
|
|
pub descr: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct OpenVpn {
|
|
#[yaserde(rename = "openvpn-server")]
|
|
pub openvpn_server: MaybeString,
|
|
#[yaserde(rename = "openvpn-client")]
|
|
pub openvpn_client: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Ppps {
|
|
pub ppp: Ppp,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Ppp {
|
|
pub ptpid: u32,
|
|
#[yaserde(rename = "type")]
|
|
pub r#type: String,
|
|
#[yaserde(rename = "if")]
|
|
pub r#if: String,
|
|
pub ports: String,
|
|
pub username: String,
|
|
pub password: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Dyndnses {
|
|
pub dyndns: Dyndns,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Dyndns {
|
|
#[yaserde(rename = "type")]
|
|
pub r#type: String,
|
|
pub username: MaybeString,
|
|
pub password: String,
|
|
pub host: String,
|
|
pub mx: MaybeString,
|
|
pub interface: String,
|
|
pub zoneid: MaybeString,
|
|
pub resourceid: MaybeString,
|
|
pub ttl: MaybeString,
|
|
pub updateurl: MaybeString,
|
|
pub resultmatch: MaybeString,
|
|
pub requestif: String,
|
|
pub descr: MaybeString,
|
|
pub id: u32,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Vlans {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
pub vlan: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Bridges {
|
|
pub bridged: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Gifs {
|
|
pub gif: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Gres {
|
|
pub gre: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Laggs {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Wireless {
|
|
pub clone: MaybeString,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Hasync {
|
|
pub synchronizealiases: String,
|
|
pub synchronizeauthservers: String,
|
|
pub synchronizecerts: String,
|
|
pub synchronizedhcpd: String,
|
|
pub synchronizenat: String,
|
|
pub synchronizerules: String,
|
|
pub synchronizeschedules: String,
|
|
pub synchronizestaticroutes: String,
|
|
pub synchronizeusers: String,
|
|
pub synchronizevirtualip: String,
|
|
pub synchronizewidgets: String,
|
|
pub synchronizedhcrelay: String,
|
|
pub synchronizedhcpdv6: String,
|
|
pub synchronizedhcrelay6: String,
|
|
pub synchronizentpd: String,
|
|
pub synchronizesyslog: String,
|
|
pub synchronizecron: String,
|
|
pub synchronizesysctl: String,
|
|
pub synchronizewebgui: String,
|
|
pub synchronizednsforwarder: String,
|
|
pub synchronizeshaper: String,
|
|
pub synchronizecaptiveportal: String,
|
|
pub synchronizeipsec: String,
|
|
pub synchronizemonit: String,
|
|
pub synchronizessh: String,
|
|
pub synchronizeopenvpn: String,
|
|
pub synchronizeifgroups: String,
|
|
pub synchronizecategories: String,
|
|
pub synchronizelvtemplate: String,
|
|
pub synchronizesquid: String,
|
|
pub synchronizesuricata: String,
|
|
pub synchronizednsresolver: String,
|
|
pub pfsyncinterface: String,
|
|
pub synchronizetoip: String,
|
|
pub username: String,
|
|
pub password: String,
|
|
pub pfsyncenabled: String,
|
|
pub disablepreempt: String,
|
|
pub disconnectppps: String,
|
|
}
|
|
|
|
#[derive(Default, PartialEq, Debug, YaSerialize, YaDeserialize)]
|
|
pub struct Ifgroups {
|
|
#[yaserde(attribute)]
|
|
pub version: String,
|
|
}
|