Struct UdpHeader

pub struct UdpHeader {
    pub fragment_number: u8,
    pub destination: Authority,
}

Layout for a header sent by a UDP Client (as request) and UDP server (as resonse), for any datagram (to be) relayed by the proxy.

A UDP-based client MUST send its datagrams to the UDP relay server at the UDP port indicated by BND.PORT in the reply to the UDP ASSOCIATE request. If the selected authentication method provides encapsulation for the purposes of authenticity, integrity, and/or confidentiality, the datagram MUST be encapsulated using the appropriate encapsulation. Each UDP datagram carries a UDP request header with it:

+----+------+------+----------+----------+----------+
|RSV | FRAG | ATYP | DST.ADDR | DST.PORT |   DATA   |
+----+------+------+----------+----------+----------+
| 2  |  1   |  1   | Variable |    2     | Variable |
+----+------+------+----------+----------+----------+

When a UDP relay server decides to relay a UDP datagram, it does so silently, without any notification to the requesting client. Similarly, it will drop datagrams it cannot or will not relay. When a UDP relay server receives a reply datagram from a remote host, it MUST encapsulate that datagram using the above UDP request header, and any authentication-method-dependent encapsulation.

The UDP relay server MUST acquire from the SOCKS server the expected IP address of the client that will send datagrams to the BND.PORT given in the reply to UDP ASSOCIATE. It MUST drop any datagrams arriving from any source IP address other than the one recorded for the particular association.

The FRAG field indicates whether or not this datagram is one of a number of fragments. If implemented, the high-order bit indicates end-of-fragment sequence, while a value of X’00’ indicates that this datagram is standalone. Values between 1 and 127 indicate the fragment position within a fragment sequence. Each receiver will have a REASSEMBLY QUEUE and a REASSEMBLY TIMER associated with these fragments. The reassembly queue must be reinitialized and the associated fragments abandoned whenever the REASSEMBLY TIMER expires, or a new datagram arrives carrying a FRAG field whose value is less than the highest FRAG value processed for this fragment sequence. The reassembly timer MUST be no less than 5 seconds. It is recommended that fragmentation be avoided by applications wherever possible.

Implementation of fragmentation is optional; an implementation that does not support fragmentation MUST drop any datagram whose FRAG field is other than X’00’.

The programming interface for a SOCKS-aware UDP MUST report an available buffer space for UDP datagrams that is smaller than the actual space provided by the operating system:

• if ATYP is X’01’: 10+method_dependent octets smaller
• if ATYP is X’03’: 262+method_dependent octets smaller
• if ATYP is X’04’: 20+method_dependent octets smaller

Fragmentation

Warning. Rama’s build in Udp associator / relayer does not support fragmentation and will reject any udp datagram with a header containing a fragment number != 0.

Data

The length of the data is not explicitly defined, nor is the data NULL terminated, instead it is to be assumed that the data (original UDP datagram) is all the bytes received in the datagram containing the header except for the first bytes encoding said header.

Fields

fragment_number: u8

destination: Authority

Implementations

impl UdpHeader

pub async fn read_from<R>(r: &mut R) -> Result<UdpHeader, ProtocolError>

where R: AsyncRead + Unpin,

Read the [UdpPacket], decoded from binary format as specified by RFC 1928 from the reader.

pub fn read_from_sync<R>(r: &mut R) -> Result<UdpHeader, ProtocolError>

where R: Read,

Read the [UdpPacket], decoded from binary format as specified by RFC 1928 from the reader.

pub fn write_to_buf<B>(&self, buf: &mut B)

where B: BufMut,

Write the [UdpPacket] in binary format as specified by RFC 1928 into the buffer.

Trait Implementations

impl Clone for UdpHeader

fn clone(&self) -> UdpHeader

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UdpHeader

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

Formats the value using the given formatter.

impl PartialEq for UdpHeader

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for UdpHeader

impl StructuralPartialEq for UdpHeader