#moonquic

// A protected packet, from the connection ID up (RFC 9001 §5.2–§5.4).
let (_, server) = @crypto.initial(dcid[:])
let number = @packet.number(1L, None)
let header = long.header(number[:], payload=payload.length() + 16)
let wire = server.seal(header[:], payload[:], number=1L)

// And back, with the packet number recovered against what this space has seen.
let (plain, n) = server.open(wire[:], largest=0L).unwrap()
let frames = @packet.read_payload(plain)

moon run src/examples/02-frames     moon run src/examples/05-ack        moon run src/examples/08-streams
moon run src/examples/03-params     moon run src/examples/06-flow       moon run src/examples/09-sender
moon run src/examples/04-crypto     moon run src/examples/07-recovery

#Packages

#Serving

let server : @conn.Endpoint[Addr] = @conn.Endpoint::server(
  @conn.Config::default(),
  @tls.Server::new(chain, key, alpn=["h3"]),
  rand=entropy,
)
server.recv(datagram, from, now)
for conn in server.take_busy() {
  for event in conn.take_events() {
    match event {
      Readable(id) => {
        let bytes = conn.read(id)
        conn.write(id, reply(bytes), fin=conn.finished(id))
      }
      _ => ()
    }
  }
}
while server.poll_out(now) is Some((datagram, to)) {
  send(datagram, to)
}

#Connecting

let client = @conn.Client::new(
  @tls.Client::new(roots, alpn=["h3"]),
  "a.example",
  @conn.encode(params),
  rand=entropy,
  dcid=Bytes::make(8, 1),
  scid=Bytes::make(8, 2),
  now,
)
for datagram in client.poll_out(now) { send(datagram, to) }
for datagram in receive() {
  client.recv(datagram, now)
  for answer in client.poll_out(now) { send(answer, to) }
}

client.tick(now)
for datagram in client.poll_out(now) { send(datagram, to) }

client.write(0UL, request, fin=true)
for datagram in client.poll_out(now) { send(datagram, to) }

#Several connections on one socket

let endpoint = @conn.ClientEndpoint::new(@conn.Config::default(), rand=entropy)
let id = endpoint.connect(
  @tls.Client::new(roots, alpn=["h3"]),
  "a.example",
  params,
  now,
)
endpoint.recv(datagram, now)
for answer in endpoint.poll_out(now) { send(answer, to) }
endpoint.tick(now)
let client = endpoint.client(id).unwrap()

#Paths

let paths = conn.paths()
paths.on_max_path_id(2UL)          // what the peer said it will accept
paths.bind(1UL, spare_cid)         // give a path an id of its own
conn.send(@conn.Level::Application, [@frame.PathStatus(path_id=1UL, seq=1UL, available=true)])

#Datagrams

let cfg = { ..@conn.Config::default(), max_datagram_frame_size: 1200UL }
let taken = conn.send_datagram(payload)
for datagram in conn.take_datagrams() { handle(datagram) }

#Everything the protocol leaves open is a parameter

@crypto.initial(dcid[:])                              // AEAD_AES_128_GCM, RFC 9001 §5.2
@crypto.Keys::of(secret[:], suite=@crypto.aes256)     // AEAD_AES_256_GCM
@crypto.Keys::of(secret[:], suite=@crypto.chacha20)   // AEAD_CHACHA20_POLY1305

@recovery.State::new()                                   // NewReno
@recovery.State::new(control=@recovery.Cubic::new())     // CUBIC, RFC 9438
@recovery.State::new(control=@recovery.Bbr::new())       // BBR

#What is not here

#Verification

#Conformance

#License