🥮 mooncakes.io

    moonbitstack/moontls/alert does not have a README file

    Alert

    source
    pub(all) suberror Alert {
      Alert(level~ : Level, kind~ : Kind)
    } derive(Eq, 
    Debug    )

    An alert (RFC 8446 §6).

    It is also the error a handshake raises, so one value carries both the reason a caller branches on and the two octets to put on the wire.
    impl Show for Alert

    Alert::equal

    source
    fn Alert::equal(Alert, Alert) -> Bool

    Alert::not_equal

    source
    fn Alert::not_equal(x : Alert, y : Alert) -> Bool

    Alert::output

    source
    fn Alert::output(self : Alert, logger : &Logger) -> Unit

    Alert::to_repr

    source

    Alert::to_string

    source
    fn Alert::to_string(self : Alert) -> String

    Kind

    source
    pub(all) enum Kind {
      CloseNotify
      UnexpectedMessage
      BadRecordMac
      RecordOverflow
      HandshakeFailure
      BadCertificate
      UnsupportedCertificate
      CertificateRevoked
      CertificateExpired
      CertificateUnknown
      IllegalParameter
      UnknownCa
      AccessDenied
      DecodeError
      DecryptError
      ProtocolVersion
      InsufficientSecurity
      InternalError
      InappropriateFallback
      UserCanceled
      NoRenegotiation
      MissingExtension
      UnsupportedExtension
      UnrecognizedName
      BadCertificateStatusResponse
      UnknownPskIdentity
      CertificateRequired
      NoApplicationProtocol
      Other(Int)
    } derive(Eq, 
    Debug    )

    What an endpoint says went wrong (RFC 8446 §6.1, §6.2).

    The description is the only diagnostic a peer ever receives, so it is what makes a failed handshake readable from the other end — a connection that simply goes away tells the client nothing.

    Other carries a code the RFC does not assign. An unrecognised description still arrives, and dropping the number would lose the only thing it said.

    Kind::code

    source
    fn Kind::code(self : Kind) -> Int

    The octet this description goes on the wire as.

    Kind::equal

    source
    fn Kind::equal(Kind, Kind) -> Bool

    Kind::is_fatal

    source
    fn Kind::is_fatal(self : Kind) -> Bool

    Whether this description ends the connection (RFC 8446 §6.1).

    Everything but CloseNotify and UserCanceled, whatever level the sender put on it — the level is advisory and the description is not.

    Kind::name

    source
    fn Kind::name(self : Kind) -> String

    The description's name as RFC 8446 §6 writes it; an unassigned one is alert_<code>.

    Kind::not_equal

    source
    fn Kind::not_equal(x : Kind, y : Kind) -> Bool

    Kind::of

    source
    fn Kind::of(code : Int) -> Kind

    The description an octet names. Never fails: one the RFC does not assign becomes Other.

    Kind::to_repr

    source

    Level

    source
    pub(all) enum Level {
      Warning
      Fatal
    } derive(Eq, 
    Debug    )

    An alert's level (RFC 8446 §6).

    TLS 1.3 acts on the description rather than the level: only CloseNotify and UserCanceled leave a connection usable, whichever level carries them. The level is still on the wire, so it is still read and written.

    Level::code

    source
    fn Level::code(self : Level) -> Int

    The octet this level goes on the wire as.

    Level::equal

    source
    fn Level::equal(Level, Level) -> Bool

    Level::not_equal

    source
    fn Level::not_equal(x : Level, y : Level) -> Bool

    Level::of

    source
    fn Level::of(code : Int) -> Level?

    The level an octet names, or None for one RFC 8446 does not assign.

    Level::to_repr

    source

    decode

    source
    fn decode(view : BytesView) -> Alert?

    Read an alert back off the wire, or None if fewer than two octets are there.

    A level the RFC does not assign is refused rather than guessed at; an unassigned description is carried through as [Kind::Other], because the description is the diagnostic and losing it loses the message.

    decoded

    source
    fn[T] decoded(read : T?) -> T raise Alert

    What a decoder read, or a fatal decode_error when it did not fit its lengths (§6.2): the step from a codec's None to the alert a peer is owed.

    encode

    source
    fn encode(alert : Alert) -> Bytes

    The two octets an alert goes on the wire as (RFC 8446 §6).

    fatal

    source
    fn fatal(kind : Kind) -> Alert

    A fatal alert carrying kind — every way a TLS 1.3 handshake can fail.

    warning

    source
    fn warning(kind : Kind) -> Alert

    A warning alert carrying kind: CloseNotify and UserCanceled, the two a peer may act on without tearing the connection down.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io