Cross-platform mechanism to set socket options

[fortuna]

We need a cross-platform and reusable mechanism to set the TTL on TCP and UDP connections.

That is needed in some strategies, for example:

• WIP: disorder siriusfreak/outline-sdk#1
• OOB and disOOB implementation siriusfreak/outline-sdk#2
• Add the "fake" strategy siriusfreak/outline-sdk#3

The ipv6 and ipv4 packages help, but it would be nicer to have a more unified API and interfaces we can use.

Current Proposal: TCPConn interface

Define a new TCP dialer and connection interfaces:

type TCPConn interface {
....
}

type TCPDialer interface {
    DialTCP(ctx context.Context, address string) (TCPConn, error)
}

Note that this will require renaming the existing transport.TCPDialer, perhaps back to TCPStreamDialer

The TCPConn type can then have all the IP and TCP options we want to support. It may be helpful to breakdown the StreamConn and TCPConn interfaces in order to better allow for wrapping:

type SendStream interface {
  SetWriteDeadline(t time.Time) error
  Write(b []byte) (int, error)
  CloseWrite() error
}

type ReceiveStream interface {
  SetReadDeadline(t time.Time) error
  Read(b []byte) (n int, err error)
  CloseRead() error
}

type TCPOptions interface {
  SetLinger(sec int) error
  SetNoDelay(noDelay bool) error
  ...
  HopLimit() (int, error)
  SetHopLimit(lim int) error
}

type StreamConn interface {
  SendStream
  ReceiveStream
  SetDeadline(t time.Time) error
  LocalAddr() net.Addr
  RemoteAddr() net.Addr  
}

type TCPConn interface {
  transport.StreamConn
  TCPOptions
}

Note that the new transport.TCPConn implements net.Conn and transport.StreamConn.

However, net.TCPConn does not implement transport.TCPConn. We will need to wrap it. But that is easy with the broken down interfaces:

type NetTCPConn struct {
  StreamConn
  TCPOptions
}

func NewNetTCPConn(netConn *net.TCPConn) transport.TCPConn {
  return NetTCPConn{
    StreamConn: netConn
    TCPOptions: NewTCPOptions(netConn)
  }
}

We can consider extracting an IPOptions from TCPOptions.

One additional note: by having a transport.TCPConn interface, rather than using net.TCPConn, we can provide alternative implementations of TCP. For example, using GVisor or lwip, which in turn can plug to a TUN device, Wireguard or OpenVPN service, etc.

In the config providers, the disorder factory function can check if the input transport.StreamDialer is of type transport.TCPDialer, validating the input type at creation time. Alternatively we can define an explicit TCPDialer provider.

The fake strategy needs a way to send data, and then edit it. It will need an interface that describes that behavior. But it also needs to work with the hop limits. So we need to think how we can extend it to support the sendfile hack, even though it's not supported on all platforms. We also need to figure out the interface for oob.

---

Previous Proposal: Option interfaces

I propose we create a new interface:

type HasHopLimit interface {
  HopLimit() (int, error)
  SetHopLimit(int) error
}

Then connections can explicitly provide an implementation. We should have functions to create a HasHopLimit from a TCPConn or UDPConn, or perhaps just net.Conn.

For the disorder Writer, it could take an innerWriter and a HasHopLimit as inputs:

func NewWriter(conn net.Conn, hopLimit HasHopLimit, prefixBytes int64) io.Writer {
  ...
}

To implement a Dialer, it needs a special inner Dialer that can return something with HopLimit. We can define a new interface:

type StreamWithHopLimitDialer interface {
  DialStreamWithHopLimit() (transport.StreamConn, HopLimit, error)
}

In the config providers, we will need to have a new provider for StreamWithHopLimitDialers. The disorder factory function will create a StreamWithHopLimitDialer, not a StreamDialer, when processing its BaseConfig.

This ensures type safety, without obscure casting.

It may be worth investigating ways to make this a bit more extensible perhaps.

The fake strategy needs a way to send data, and then edit it. It will need an interface that describes that behavior. But it also needs to work with the hop limits. So we need both. oob will need an interface to set the OOB. How do we make that scalable?

Thoughts?

[fortuna]

We can also simplify and just make disorder, fake and oob take a TCPDialer as input. We can have a TCPDialer provider in the config. This actually sounds a lot simpler then my complicated proposal above! 😅

Though technically fake needs more than a TCPDialer...

[fortuna]

For the simpler proposal, we probably need to define an interface for TCP and UDP Dialers with DialTCP/DialUDP methods that return TCPConn or UDPConn.

[fortuna]

See #316 for an implementation of TCPOptions.