wip

standards/cap/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "rasn-cap"
+version = "0.6.0"
+edition = "2018"
+description = "Data types for the Common Alerting Protocol (CAP 1.1)"
+license = "Apache-2.0/MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rasn = { path = "../..", version = "0.6.0" }

standards/cap/README.md

@@ -0,0 +1,7 @@
+# Online Certificate Status Protocol
+This crate provides an implementation of the data types for [RFC 6960], also
+known as Online Certificate Status Protocol (OCSP).
+
+Like other `rasn` core crates, this doesn't provide a OCSP client or server
+but provides the core data types used to be able to create your own clients
+and servers.

standards/cap/src/lib.rs

@@ -0,0 +1,278 @@
+#![doc = include_str!("../README.md")]
+#![no_std]
+
+use rasn::prelude::*;
+
+pub type ValueName = String;
+pub type Value = String;
+pub type DateTime = rasn::types::GeneralizedTime;
+pub type AnyUri = StringWithNoCrlFht;
+
+/// An alert message.
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(automatic_tags)]
+pub struct Alert {
+    /// Unambiguous identification of the message from all messages from this
+    /// sender, in a format defined by the sender and identified in the "sender"
+    /// field below.
+    pub identifier: IdentifierString,
+
+    /// The globally unambiguous identification of the sender. This
+    /// specification does not define the root of a global identification tree
+    /// (there is no international agreement on such a root), so it relies on
+    /// human-readable text to define globally and unambiguously the sender. An
+    /// internet domain name or use of "iri:/ITU-T/..." is possible, but the
+    /// choice needs to be clearly stated in human-readable form.
+    pub sender: String,
+    pub sent: DateTime,
+    pub status: AlertStatus,
+    pub msg_type: AlertMessageType,
+
+    /// Not standardized human-readable identification of the source of
+    /// the alert.
+    pub source: Option<String>,
+    pub scope: AlertScope,
+
+    /// Not standardized human-readable restrictions on the distribution of the
+    /// alert message.
+    pub restriction: Option<String>,
+    /// A space separated list of addresses for private messages.
+    pub addresses: Option<String>,
+    /// Sequence codes for special handling.
+    pub code_list: SequenceOf<String>,
+    /// Not standardized human-readable clarifying text for the alert.
+    pub note: Option<String>,
+    /// Space-separated references to earlier messages.
+    pub references: Option<String>,
+    /// Space-separated references to related incidents.
+    pub incidents: Option<String>,
+    pub info_list: SequenceOf<AlertInformation>,
+}
+
+#[derive(AsnType, Clone, Copy, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(enumerated)]
+pub enum AlertStatus {
+    Actual,
+    Draft,
+    Exercise,
+    System,
+    Test,
+}
+
+#[derive(AsnType, Clone, Copy, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(enumerated)]
+pub enum AlertMessageType {
+    Ack,
+    Alert,
+    Cancel,
+    Error,
+    Update,
+}
+
+#[derive(AsnType, Clone, Copy, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(enumerated)]
+pub enum AlertScope {
+    Private,
+    Public,
+    Restricted
+}
+
+fn default_alert_language() -> Language {
+    Language("en-US".into())
+}
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(automatic_tags)]
+pub struct AlertEventCode {
+    pub value_name: ValueName,
+    pub value: Value
+}
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(automatic_tags)]
+pub struct AlertParameter {
+    value_name: ValueName,
+    value: Value,
+}
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(automatic_tags)]
+pub struct AlertInformation {
+    /// The language used in this value.
+    #[rasn(default="default_alert_language")]
+    language: Language,
+    #[rasn(size(1..max))]
+    category_list: SequenceOf<InformationCategory>,
+
+    /// Not standardized human-readable text describing the type of the event.
+    event: String,
+    #[rasn(size(0..max))]
+    response_type_list: SequenceOf<InformationResponseType>,
+    urgency: HowUrgent,
+    severity: HowSevere,
+    certainty: HowCertain,
+
+    /// Not standardized human-readable text describing the intended audience
+    /// for the message.
+    audience: Option<String>,
+
+    #[rasn(size(0..max))]
+    event_code_list: SequenceOf<AlertEventCode>,
+    effective: Option<DateTime>,
+    onset: Option<DateTime>,
+    expires: Option<DateTime>,
+
+    /// Not standardized human-readable name of the authority issuing
+    /// the message.
+    sender_name: Option<String>,
+
+    /// Not standardized human-readable short statement (headline) of the alert.
+    #[rasn(size(1..160), extensible)]
+    headline: Option<String>,
+
+    /// Not standardized human-readable extended description of the event.
+    description: Option<String>,
+    /// Not standardized human-readable recommended action.
+    instruction: Option<String>,
+    web: Option<AnyUri>,
+    /// Not standardized human-readable contact details for follow-up.
+    contact: Option<String>,
+    #[rasn(size(0..max))]
+    parameter_list: SequenceOf<AlertParameter>,
+    #[rasn(size(0..max))]
+    resource_list: SequenceOf<ResourceFile>,
+    #[rasn(size(0..max))]
+    area_list: SequenceOf<Area>,
+}
+
+/// The category of the subject event of the alert message.
+#[derive(AsnType, Copy, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(enumerated)]
+pub enum InformationCategory {
+    /// Chemical, Biological, Radiological, Nuclear or High-Yield Explosive
+    /// threat or attack
+    Cbrne,
+    /// Pollution and other environmental
+    Env,
+    /// Fire suppression and rescue
+    Fire,
+    /// Geophysical
+    Geo,
+    /// Medical and public health
+    Health,
+    /// Utility, telecommunication, other non-transport infrastructure
+    Infra,
+    /// Meteorological
+    Met,
+    /// Other events
+    Other,
+    /// Rescue and recovery
+    Rescue,
+    /// General emergency and public safety
+    Safety,
+    /// Law enforcement, military, homeland and local/private security
+    Security,
+    /// Public and private transportation
+    Transport
+}
+
+#[derive(AsnType, Copy, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(enumerated)]
+pub enum InformationResponseType {
+    Assess,
+    Evacuate,
+    Execute,
+    Monitor,
+    None,
+    Prepare,
+    Shelter,
+}
+
+#[derive(AsnType, Copy, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(enumerated)]
+pub enum HowUrgent {
+    Expected,
+    Future,
+    Immediate,
+    Past,
+    Unknown
+}
+
+#[derive(AsnType, Copy, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(enumerated)]
+pub enum HowSevere {
+    Extreme,
+    Minor,
+    Moderate,
+    Severe,
+    Unknown,
+}
+
+#[derive(AsnType, Copy, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(enumerated)]
+pub enum HowCertain {
+    Likely,
+    Observed,
+    Possible,
+    Unknown,
+    Unlikely,
+}
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(automatic_tags)]
+pub struct ResourceFile {
+    resource_desc: String,
+    mime_type: Option<String>,
+    size: Option<Integer>,
+    uri: Option<AnyUri>,
+    deref_uri: Option<String>,
+    digest: Option<String>,
+}
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(automatic_tags)]
+pub struct Area {
+    area_desc: String,
+    polygon_list: SequenceOf<String>,
+    circle_list: SequenceOf<String>,
+    #[rasn(size(0..max))]
+    geocode_list: SequenceOf<Geocode>,
+    altitude: Option<String>,
+    ceiling: Option<String>,
+}
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(automatic_tags)]
+pub struct Geocode {
+    value_name: ValueName,
+    value: Value,
+}
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(from('\u{0009}' | '\u{000A}' | '\u{000D}' | '\u{0020}'..'\u{D7FF}' | '\u{E000}'..'\u{FFFD}' | '\u{10000}'..'\u{10FFFD}'))]
+#[rasn(delegate)]
+pub struct String(Utf8String);
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(size(1))]
+#[rasn(delegate)]
+pub struct StringChar(String);
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(from('\u{0020}' | '\u{002C}'))]
+#[rasn(delegate)]
+pub struct SpaceAndComma(Utf8String);
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(delegate)]
+pub struct IdentifierString(StringChar);
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(from('a'..'z' | 'A'..'Z' | '-' | '0'..'9'), pattern(r#"[a-zA-Z]#(1,8)(-[a-zA-Z0-9]#(1,8))*"#))]
+#[rasn(delegate)]
+pub struct Language(VisibleString);
+
+#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[rasn(from('\u{20}'..'\u{D7FF}' | '\u{E000}'..'\u{FFFD}' | '\u{10000}'..'\u{100000}'))]
+#[rasn(delegate)]
+pub struct StringWithNoCrlFht(Utf8String);