Returns the current clock era.

Divides the timestamp by two.

Spawn the provided task, then spawn another task that supervises its join handle and signals for shutdown if it errored or panicked

Wrapping addition of timestamps. Computess `self` + `rhs`, wrapping around at the boundary of the type.

Silly helper function that really ought to already be in rkv

Multiplies the timestamp by `ppb` parts per billion.

Returns an estimate of (global clock - our local clock) based on information from this peer

Wrapping subtraction of timestamps. Computess `self` - `rhs`, wrapping around at the boundary of the type.

Saturating subtraction of timestamps. Computes `self` - `rhs`, saturating at numeric bounds instead of overflowing.

Encrypt a cookie using the given master key

Return the seconds portion of the timestamp

Look up the current master key and index from our cache

Return the nanoseconds portion of the timestamp

Decrypt a cookie, using the given callback to look up the master key by its ID.

Calculates `self` + `rhs`. Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow occurred. If an overflow oc

Normalizes the timestamp such that 0 ≤ nanoseconds < 1_000_000_000. Returns a tuple of the normalized timestamp along with a boolean indicating wheth

Multiplies the timestamp by `ppb` parts per billion. Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic over

Calculates `self` - `rhs`. Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow occurred. If an overflow

Asynchronously read and parse NTS-KE records from `stream`.

Costruct a response to a time request Parses the request in `recv_buf` and places an appropriate response in `send_buf`. Returns as follows: `Ok(Ok((

Normalizes the timestamp such that 0 ≤ nanoseconds < 1_000_000_000.

Set the C2S, S2C, and cookies for a peer, discarding any existing cookies

Asynchronously serialize and write `records` to `stream`.

Build a log4rs config from a sequence of `LogConfig`s returned by the iterator

Checked addition of timestamps. Computes `self` + `rhs`, returning `None` if overflow occurred.

log4rs is missing derived traits for Target, so we have to manually reimplement this.

Returns the maximum absolute estimation error of local_offset. `drift_ppb`: Upper bound on rate of clock drift, in parts per billion `dist`: Lower bo

Extend `v` with a serialized representation of this record.

Extract Byztime C2S and S2C keys from a TLS session.

Find available ports to use for byztimed tests Returns a vector of `num_ports` port numbers that are available for both UDP and TCP. Every invocation

Insert the cookies for the given peer into the store, retaining up to a maximum of 16

Process a time response Deserialize and decrypt the `response` using `secret_store` to look up keys. Pass the response to `core_state`. Add any retur

Initialize logging

Determine whether an NTS-KE response is well-formed and whether it communicates success or failure. If successful, return the provided cookies.

Returns the `offset` that was stored by the last call to [set_offset](Self::set_offset).

Called at each polling interval for each peer, and returns a query to send to that peer. The caller is responsible for prompty transmitting the query

Parse an NTS-KE record. `head` is the first four bytes of the record (containing record type and body length) `body is the rest.

Parse a string of big-endian 16-bit unsigned integers.

Returns the record number indicating the type of this record.

Reinitialize logging (useful for reopening log files after they've been rotated)

Construct a response appropriate to a given NTS-KE request.

Saturating addition of timestamps. Computes `self` + `rhs`, saturating at numeric bounds instead of overflowing.

SIGINT/SIGTERM handler

Recompute our global offset estimate from newly-updated peer clocks.

Multiplies the timestamp by `ppb` parts per billion, wrapping around at the limits of the type if overflow occurs.

Returns how long this record's body will be when serialized.

Checked subtractions of timestamps. Computes `self` - `rhs`, returning `None` if overflow occurred.

Clear all credentials for the peer

Semantically validate a parsed configuration and fill in defaults

Deserialize a time request Fully deserialize and decrypt `request`, using `get_master_key` to look up master keys by ID

Deserialize a time response as far as the envelope, but don't try to decrypt it

Deserialize the plaintext of a time response, returning cookies and a [`core::Response`](../core/struct.Response.html).

Look up the C2S key for the given peer

Look up the master key with the given index from the cache

Look up the master key with the given index, from cache if possible, otherwise from disk

Look up the S2C key for the given peer

Look up the current global time and error bounds and store them into the provided references.

Return whether this record is critical, i.e., whether the receiver should treat it as an error if it's not understood rather than ignoring it. The arg

The time that it takes for light to travel 10**9 meters through a vacuum

SIGHUP handler

Normalizes the timestamp such that 0 ≤ nanoseconds < 1_000_000_000.

Task for serving NTS-KE requests

Look up the current estimated offset (global clock - local clock) and error bounds and store them into the provided references.

Returns the `(offset, error, as_of)` tuple that was stored by the last call to [set_offset](Self::set_offset).