Struct AddrPolicy 

pub struct AddrPolicy {
    rules: Vec<AddrPolicyRule>,
}

Sequence of accept and reject rules

https://spec.torproject.org/dir-spec/server-descriptor-format.html#item:accept

Encodable in netdocs, and parseable as NetdocParseableFields.

A specific address:port is tested against them in order; first match wins. Each rule is of the form “accept PATTERN” or “reject PATTERN”, where every pattern describes a set of addresses and ports. Address sets are given as a prefix of 0-128 bits that the address must have; port sets are given as a low-bound and high-bound that the target port might lie between.

Relays use this type for defining their own policies, and for publishing their IPv4 policies. Clients instead use super::portpolicy::PortPolicy objects to view a summary of the relays’ declared policies.

An example IPv4 policy might be:

 reject *:25
 reject 127.0.0.0/8:*
 reject 192.168.0.0/16:*
 accept *:80
 accept *:443
 accept *:9000-65535
 reject *:*

Default is the all-reject policy, also constructible with AddrPolicy::new.

Fields

rules: Vec<AddrPolicyRule>

A list of rules to apply to find out whether an address is contained by this policy.

The rules apply in order; the first one to match determines whether the address is accepted or rejected.

Implementations

impl AddrPolicy

pub fn allows(&self, addr: &IpAddr, port: u16) -> Option<RuleKind>

Apply this policy to an address:port combination

We do this by applying each rule in sequence, until one matches.

Returns None if no rule matches.

pub fn allows_sockaddr(&self, addr: &SocketAddr) -> Option<RuleKind>

As allows, but accept a SocketAddr.

pub fn new() -> Self

Create a new AddrPolicy that matches nothing.

pub fn push(&mut self, kind: RuleKind, pattern: AddrPortPattern)

Add a new rule to this policy.

The newly added rule is applied after all previous rules. It matches all addresses and ports covered by AddrPortPattern.

If accept is true, the rule is to accept addresses that match; if accept is false, the rule rejects such addresses.

pub fn rules( &self, ) -> impl DoubleEndedIterator<Item = (RuleKind, AddrPortPattern)> + '_

List the rules in this pattern

impl AddrPolicy

pub fn summarise_precise( &self, thresholds: &PortSummaryThresholds, private_ranges: impl IntoIterator<Item = IpNet>, ) -> PortPolicies

Calculate port policy summaries using a precise but unhardened algorithm

Returns two Exit Policy Summaries, one for for each of IPv4 and IPv6. https://spec.torproject.org/dir-spec/computing-consensus.html#exit-summary

Not generally suitable for use on untrusted input because there is no effort to limit the computational complexity.

Useful for a router, when calculating ipv6-policy in its router descriptor, from its own (locally configured) accept/reject policy.

The result is calculated according to this rule:

A port should be summarised as accepted iff the full exit policy permits “most” “public” addresses on that port.

summarise_precise implements the rule precisely as specified there; not the hardened approximate algorithm used by dirauths for IPv4 summaries.

private_ranges is the ranges considered not “public”. Rejections of addresses in these ranges are disregarded when considering whether a port is open.

This algorithm does not handle “IPv4-mapped Addresses” (ie, IPv6-mapped IPv4 addresses) specially. They should normally be rejected, and be in private_ranges.

thresholds should normally be &PortSummaryThresholds::DEFAULT.

Trait Implementations

impl Clone for AddrPolicy

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AddrPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AddrPolicy

fn default() -> Self

Returns the “default value” for a type.

impl Eq for AddrPolicy

impl NetdocEncodableFields for AddrPolicy

fn encode_fields(&self, out: &mut NetdocEncoder) -> Result<(), Bug>

Append the document onto out

impl NetdocParseableFields for AddrPolicy

type Accumulator = AddrPolicy

The partially-parsed set of items.

fn is_item_keyword(kw: KeywordRef<'_>) -> bool

Is this one of the keywords in this struct

fn accumulate_item( acc: &mut Self::Accumulator, item: UnparsedItem<'_>, ) -> Result<(), EP>

Accumulate an item in this struct

fn finish(acc: Self::Accumulator, _: &ItemStream<'_>) -> Result<Self, EP>

Finish

impl PartialEq for AddrPolicy

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for AddrPolicy