package proxyproto
Import Path
github.com/pires/go-proxyproto (on go.dev)
Dependency Relation
imports 14 packages, and imported by one package
Involved Source Files
addr_proto.go
Package proxyproto implements Proxy Protocol (v1 and v2) parser and writer, as per specification:
https://www.haproxy.org/download/2.3/doc/proxy-protocol.txt
policy.go
protocol.go
tlv.go
v1.go
v2.go
version_cmd.go
Code Examples
package main
import (
"net"
"github.com/pires/go-proxyproto"
)
func main() {
l, _ := net.Listen("tcp", "127.0.0.1:0")
pl := &proxyproto.Listener{Listener: l}
defer func() { _ = pl.Close() }()
go func() {
c, _ := net.Dial("tcp", pl.Addr().String())
if c != nil {
_, _ = c.Write([]byte("x"))
_ = c.Close()
}
}()
conn, _ := pl.Accept()
if conn != nil {
buf := make([]byte, 1)
_, _ = conn.Read(buf)
_ = conn.Close()
}
}
package main
import (
"net"
"github.com/pires/go-proxyproto"
)
// proxyV1Line is a minimal PROXY protocol v1 header for examples.
const proxyV1Line = "PROXY TCP4 192.168.1.1 192.168.1.2 12345 443\r\n"
func main() {
l, _ := net.Listen("tcp", "127.0.0.1:0")
pl := &proxyproto.Listener{
Listener: l,
Policy: func(net.Addr) (proxyproto.Policy, error) { return proxyproto.REQUIRE, nil },
}
defer func() { _ = pl.Close() }()
go func() {
c, _ := net.Dial("tcp", pl.Addr().String())
if c != nil {
_, _ = c.Write([]byte(proxyV1Line))
_, _ = c.Write([]byte("p"))
_ = c.Close()
}
}()
conn, _ := pl.Accept()
if conn != nil {
buf := make([]byte, 1)
_, _ = conn.Read(buf)
_ = conn.Close()
}
}
package main
import (
"net"
"github.com/pires/go-proxyproto"
)
func main() {
l, _ := net.Listen("tcp", "127.0.0.1:0")
pl := &proxyproto.Listener{
Listener: l,
ReadBufferSize: 4096,
}
defer func() { _ = pl.Close() }()
go func() {
c, _ := net.Dial("tcp", pl.Addr().String())
if c != nil {
_, _ = c.Write([]byte("b"))
_ = c.Close()
}
}()
conn, _ := pl.Accept()
if conn != nil {
buf := make([]byte, 1)
_, _ = conn.Read(buf)
_ = conn.Close()
}
}
package main
import (
"net"
"time"
"github.com/pires/go-proxyproto"
)
func main() {
l, _ := net.Listen("tcp", "127.0.0.1:0")
pl := &proxyproto.Listener{
Listener: l,
ReadHeaderTimeout: 2 * time.Second,
}
defer func() { _ = pl.Close() }()
go func() {
c, _ := net.Dial("tcp", pl.Addr().String())
if c != nil {
_, _ = c.Write([]byte("a"))
_ = c.Close()
}
}()
conn, _ := pl.Accept()
if conn != nil {
_ = conn.SetReadDeadline(time.Now().Add(time.Second))
buf := make([]byte, 1)
_, _ = conn.Read(buf)
_ = conn.Close()
}
}
package main
import (
"net"
"github.com/pires/go-proxyproto"
)
// proxyV1Line is a minimal PROXY protocol v1 header for examples.
const proxyV1Line = "PROXY TCP4 192.168.1.1 192.168.1.2 12345 443\r\n"
func main() {
l, _ := net.Listen("tcp", "127.0.0.1:0")
pl := &proxyproto.Listener{
Listener: l,
ValidateHeader: func(*proxyproto.Header) error { return nil },
}
defer func() { _ = pl.Close() }()
go func() {
c, _ := net.Dial("tcp", pl.Addr().String())
if c != nil {
_, _ = c.Write([]byte(proxyV1Line))
_, _ = c.Write([]byte("v"))
_ = c.Close()
}
}()
conn, _ := pl.Accept()
if conn != nil {
buf := make([]byte, 1)
_, _ = conn.Read(buf)
_ = conn.Close()
}
}
package main
import (
"net"
"time"
"github.com/pires/go-proxyproto"
)
func main() {
serverConn, clientConn := net.Pipe()
defer func() { _ = serverConn.Close() }()
defer func() { _ = clientConn.Close() }()
go func() {
_, _ = clientConn.Write([]byte("c"))
_ = clientConn.Close()
}()
conn := proxyproto.NewConn(serverConn,
proxyproto.WithBufferSize(2048),
proxyproto.SetReadHeaderTimeout(2*time.Second),
)
buf := make([]byte, 1)
_, _ = conn.Read(buf)
}
package main
import (
"net"
"github.com/pires/go-proxyproto"
)
func main() {
serverConn, clientConn := net.Pipe()
defer func() { _ = serverConn.Close() }()
defer func() { _ = clientConn.Close() }()
go func() {
_, _ = clientConn.Write([]byte("x"))
_ = clientConn.Close()
}()
conn := proxyproto.NewConn(serverConn)
buf := make([]byte, 1)
_, _ = conn.Read(buf)
}
package main
import (
"net"
"github.com/pires/go-proxyproto"
)
func main() {
serverConn, clientConn := net.Pipe()
defer func() { _ = serverConn.Close() }()
defer func() { _ = clientConn.Close() }()
go func() {
_, _ = clientConn.Write([]byte("y"))
_ = clientConn.Close()
}()
conn := proxyproto.NewConn(serverConn, proxyproto.WithBufferSize(4096))
buf := make([]byte, 1)
_, _ = conn.Read(buf)
}
{
serverConn, clientConn := net.Pipe()
defer func() { _ = serverConn.Close() }()
defer func() { _ = clientConn.Close() }()
go func() {
_, _ = clientConn.Write([]byte(proxyV1Line))
_, _ = clientConn.Write([]byte("p"))
_ = clientConn.Close()
}()
conn := proxyproto.NewConn(serverConn, proxyproto.WithPolicy(proxyproto.REQUIRE))
buf := make([]byte, 1)
_, _ = conn.Read(buf)
}
package main
import (
"net"
"time"
"github.com/pires/go-proxyproto"
)
func main() {
serverConn, clientConn := net.Pipe()
defer func() { _ = serverConn.Close() }()
defer func() { _ = clientConn.Close() }()
go func() {
_, _ = clientConn.Write([]byte("z"))
_ = clientConn.Close()
}()
conn := proxyproto.NewConn(serverConn, proxyproto.SetReadHeaderTimeout(time.Second))
buf := make([]byte, 1)
_, _ = conn.Read(buf)
}
Package-Level Type Names (total 12)
AddressFamilyAndProtocol represents address family and transport protocol.
IsDatagram returns true if the transport protocol is UDP or DGRAM (SOCK_DGRAM), false otherwise.
IsIPv4 returns true if the address family is IPv4 (AF_INET4), false otherwise.
IsIPv6 returns true if the address family is IPv6 (AF_INET6), false otherwise.
IsStream returns true if the transport protocol is TCP or STREAM (SOCK_STREAM), false otherwise.
IsUnix returns true if the address family is UNIX (AF_UNIX), false otherwise.
IsUnspec returns true if the transport protocol or address family is unspecified, false otherwise.
const TCPv4
const TCPv6
const UDPv4
const UDPv6
const UnixDatagram
const UnixStream
const UNSPEC
Conn is used to wrap and underlying connection which
may be speaking the Proxy Protocol. If it is, the RemoteAddr() will
return the address of the client instead of the proxy address. Each connection
will have its own readHeaderTimeout and readDeadline set by the Accept() call.
ProxyHeaderPolicy Policy
Validate Validator
Close wraps original conn.Close.
LocalAddr returns the address of the server if the proxy
protocol is being used, otherwise just returns the address of
the socket server. In case an error happens on reading the
proxy header the original LocalAddr is returned, not the one
from the proxy header even if the proxy header itself is
syntactically correct.
ProxyHeader returns the proxy protocol header, if any. If an error occurs
while reading the proxy header, nil is returned.
Raw returns the underlying connection which can be casted to
a concrete type, allowing access to specialized functions.
Use this ONLY if you know exactly what you are doing.
Read is check for the proxy protocol header when doing
the initial scan. If there is an error parsing the header,
it is returned and the socket is closed.
ReadFrom implements the io.ReaderFrom ReadFrom method.
RemoteAddr returns the address of the client if the proxy
protocol is being used, otherwise just returns the address of
the socket peer. In case an error happens on reading the
proxy header the original RemoteAddr is returned, not the one
from the proxy header even if the proxy header itself is
syntactically correct.
SetDeadline wraps original conn.SetDeadline.
SetReadDeadline wraps original conn.SetReadDeadline.
SetWriteDeadline wraps original conn.SetWriteDeadline.
TCPConn returns the underlying TCP connection,
allowing access to specialized functions.
Use this ONLY if you know exactly what you are doing.
UDPConn returns the underlying UDP connection,
allowing access to specialized functions.
Use this ONLY if you know exactly what you are doing.
UnixConn returns the underlying Unix socket connection,
allowing access to specialized functions.
Use this ONLY if you know exactly what you are doing.
Write wraps original conn.Write.
WriteTo implements io.WriterTo.
*Conn : github.com/miekg/dns.Writer
*Conn : github.com/pion/datachannel.ReadDeadliner
*Conn : github.com/pion/datachannel.WriteDeadliner
*Conn : github.com/pion/stun.Connection
*Conn : github.com/pion/stun/v3.Connection
*Conn : github.com/prometheus/common/expfmt.Closer
*Conn : internal/bisect.Writer
*Conn : io.Closer
*Conn : io.ReadCloser
*Conn : io.Reader
*Conn : io.ReaderFrom
*Conn : io.ReadWriteCloser
*Conn : io.ReadWriter
*Conn : io.WriteCloser
*Conn : io.Writer
*Conn : io.WriterTo
*Conn : net.Conn
func NewConn(conn net.Conn, opts ...func(*Conn)) *Conn
ConnPolicyFunc can be used to decide whether to trust the PROXY info
based on connection policy options. If set, the connecting addresses
(remote and local) are passed in as argument.
See below for the different policies.
In case an error is returned the connection is denied.
func ConnLaxWhiteListPolicy(allowed []string) (ConnPolicyFunc, error)
func ConnMustLaxWhiteListPolicy(allowed []string) ConnPolicyFunc
func ConnMustStrictWhiteListPolicy(allowed []string) ConnPolicyFunc
func ConnSkipProxyHeaderForCIDR(skipHeaderCIDR *net.IPNet, def Policy) ConnPolicyFunc
func ConnStrictWhiteListPolicy(allowed []string) (ConnPolicyFunc, error)
func IgnoreProxyHeaderNotOnInterface(allowedIP net.IP) ConnPolicyFunc
func TrustProxyHeaderFrom(trustedIPs ...net.IP) ConnPolicyFunc
ConnPolicyOptions contains the remote and local addresses of a connection.
Downstream net.Addr
Upstream net.Addr
Header is the placeholder for proxy protocol header.
Command ProtocolVersionAndCommand
DestinationAddr net.Addr
SourceAddr net.Addr
TransportProtocol AddressFamilyAndProtocol
Version byte
EqualTo returns true if headers are equivalent, false otherwise.
Deprecated: use EqualsTo instead. This method will eventually be removed.
EqualsTo returns true if headers are equivalent, false otherwise.
Format renders a proxy protocol header in a format to write over the wire.
IPs returns source/destination IPs for TCP/UDP headers.
Ports returns source/destination ports for TCP/UDP headers.
SetTLVs sets the TLVs stored in this header. This method replaces any
previous TLV.
TCPAddrs returns TCP source/destination addresses if the header is stream-based.
TLVs returns the TLVs stored into this header, if they exist. TLVs are optional for v2 of the protocol.
UDPAddrs returns UDP source/destination addresses if the header is datagram-based.
UnixAddrs returns UNIX source/destination addresses if the header is UNIX-based.
WriteTo renders a proxy protocol header in a format and writes it to an io.Writer.
*Header : io.WriterTo
func HeaderProxyFromAddrs(version byte, sourceAddr, destAddr net.Addr) *Header
func Read(reader *bufio.Reader) (*Header, error)
func ReadTimeout(reader *bufio.Reader, timeout time.Duration) (*Header, error)
func (*Conn).ProxyHeader() *Header
func (*Header).EqualsTo(otherHeader *Header) bool
func (*Header).EqualTo(otherHeader *Header) bool
Listener is used to wrap an underlying listener,
whose connections may be using the HAProxy Proxy Protocol.
If the connection is using the protocol, the RemoteAddr() will return
the correct client address. ReadHeaderTimeout will be applied to all
connections in order to prevent blocking operations. If no ReadHeaderTimeout
is set, a default of 10s will be used. This can be disabled by setting the
timeout to < 0.
Only one of Policy or ConnPolicy should be provided. If both are provided then
a panic would occur during accept.
ConnPolicy is the policy function for accepted connections.
Listener is the underlying listener.
Deprecated: use ConnPolicyFunc instead. This will be removed in future release.
ReadBufferSize is the read buffer size for accepted connections. When > 0,
each accepted connection uses this size for proxy header detection; 0 means default.
ReadHeaderTimeout is the timeout for reading the proxy header.
ValidateHeader is the validator function for the proxy header.
Accept waits for and returns the next valid connection to the listener.
Addr returns the underlying listener's network address.
Close closes the underlying listener.
*Listener : github.com/prometheus/common/expfmt.Closer
*Listener : io.Closer
*Listener : net.Listener
Policy defines how a connection with a PROXY header address is treated.
func ConnSkipProxyHeaderForCIDR(skipHeaderCIDR *net.IPNet, def Policy) ConnPolicyFunc
func SkipProxyHeaderForCIDR(skipHeaderCIDR *net.IPNet, def Policy) PolicyFunc
func WithPolicy(p Policy) func(*Conn)
const IGNORE
const REJECT
const REQUIRE
const SKIP
const USE
PolicyFunc can be used to decide whether to trust the PROXY info from
upstream. If set, the connecting address is passed in as an argument.
See below for the different policies.
In case an error is returned the connection is denied.
Deprecated: use ConnPolicyFunc instead.
func LaxWhiteListPolicy(allowed []string) (PolicyFunc, error)
func MustLaxWhiteListPolicy(allowed []string) PolicyFunc
func MustStrictWhiteListPolicy(allowed []string) PolicyFunc
func SkipProxyHeaderForCIDR(skipHeaderCIDR *net.IPNet, def Policy) PolicyFunc
func StrictWhiteListPolicy(allowed []string) (PolicyFunc, error)
PP2Type is the proxy protocol v2 type.
App is true if the type is reserved for application specific data, see section 2.2.7.
Experiment is true if the type is reserved for temporary experimental use by application
developers, see section 2.2.7.
Future is true is the type is reserved for future use, see section 2.2.7.
Registered is true if the type is registered in the spec, see section 2.2.
Spec is true if the type is covered by the spec, see section 2.2 and 2.2.7.
const PP2_SUBTYPE_SSL_CIPHER
const PP2_SUBTYPE_SSL_CLIENT_CERT
const PP2_SUBTYPE_SSL_CN
const PP2_SUBTYPE_SSL_GROUP
const PP2_SUBTYPE_SSL_KEY_ALG
const PP2_SUBTYPE_SSL_SIG_ALG
const PP2_SUBTYPE_SSL_SIG_SCHEME
const PP2_SUBTYPE_SSL_VERSION
const PP2_TYPE_ALPN
const PP2_TYPE_AUTHORITY
const PP2_TYPE_CRC32C
const PP2_TYPE_MAX_CUSTOM
const PP2_TYPE_MAX_EXPERIMENT
const PP2_TYPE_MAX_FUTURE
const PP2_TYPE_MIN_CUSTOM
const PP2_TYPE_MIN_EXPERIMENT
const PP2_TYPE_MIN_FUTURE
const PP2_TYPE_NETNS
const PP2_TYPE_NOOP
const PP2_TYPE_SSL
const PP2_TYPE_UNIQUE_ID
ProtocolVersionAndCommand represents the command in proxy protocol v2.
Command doesn't exist in v1 but it should be set since other parts of
this library may rely on it for determining connection details.
IsLocal returns true if the command in v2 is LOCAL or the transport in v1 is UNKNOWN,
i.e. when no address information is expected, false otherwise.
IsProxy returns true if the command in v2 is PROXY or the transport in v1 is not UNKNOWN,
i.e. when valid local/remote address and port information is expected, false otherwise.
IsUnspec returns true if the command is unspecified, false otherwise.
const LOCAL
const PROXY
TLV is a uninterpreted Type-Length-Value for V2 protocol, see section 2.2.
Type PP2Type
Value []byte
func SplitTLVs(raw []byte) ([]TLV, error)
func (*Header).TLVs() ([]TLV, error)
func JoinTLVs(tlvs []TLV) ([]byte, error)
func (*Header).SetTLVs(tlvs []TLV) error
Validator receives a header and decides whether it is a valid one
In case the header is not deemed valid it should return an error.
func ValidateHeader(v Validator) func(*Conn)
Package-Level Functions (total 22)
ConnLaxWhiteListPolicy returns a ConnPolicyFunc which decides whether the
upstream ip is allowed to send a proxy header based on a list of allowed
IP addresses and IP ranges. In case upstream IP is not in list the proxy
header will be ignored. If one of the provided IP addresses or IP ranges
is invalid it will return an error instead of a ConnPolicyFunc.
ConnMustLaxWhiteListPolicy returns a ConnLaxWhiteListPolicy but will panic
if one of the provided IP addresses or IP ranges is invalid.
ConnMustStrictWhiteListPolicy returns a ConnStrictWhiteListPolicy but will panic
if one of the provided IP addresses or IP ranges is invalid.
ConnSkipProxyHeaderForCIDR returns a ConnPolicyFunc which can be used to accept
a connection from a skipHeaderCIDR without requiring a PROXY header, e.g.
Kubernetes pods local traffic. The def is a policy to use when an upstream
address doesn't match the skipHeaderCIDR.
ConnStrictWhiteListPolicy returns a ConnPolicyFunc which decides whether the
upstream ip is allowed to send a proxy header based on a list of allowed
IP addresses and IP ranges. In case upstream IP is not in list reading on
the connection will be refused on the first read. Please note: subsequent
reads do not error. It is the task of the code using the connection to
handle that case properly. If one of the provided IP addresses or IP
ranges is invalid it will return an error instead of a ConnPolicyFunc.
HeaderProxyFromAddrs creates a new PROXY header from a source and a
destination address. If version is zero, the latest protocol version is
used.
The header is filled on a best-effort basis: if hints cannot be inferred
from the provided addresses, the header will be left unspecified.
IgnoreProxyHeaderNotOnInterface returns a ConnPolicyFunc which can be used to
decide whether to use or ignore PROXY headers depending on the connection
being made on specific interfaces. This policy can be used when the server
is bound to multiple interfaces but wants to allow on one or more interfaces.
JoinTLVs joins multiple Type-Length-Value records.
LaxWhiteListPolicy returns a PolicyFunc which decides whether the
upstream ip is allowed to send a proxy header based on a list of allowed
IP addresses and IP ranges. In case upstream IP is not in list the proxy
header will be ignored. If one of the provided IP addresses or IP ranges
is invalid it will return an error instead of a PolicyFunc.
Deprecated: use ConnLaxWhiteListPolicy instead.
MustLaxWhiteListPolicy returns a LaxWhiteListPolicy but will panic if one
of the provided IP addresses or IP ranges is invalid.
Deprecated: use ConnMustLaxWhiteListPolicy instead.
MustStrictWhiteListPolicy returns a StrictWhiteListPolicy but will panic
if one of the provided IP addresses or IP ranges is invalid.
Deprecated: use ConnMustStrictWhiteListPolicy instead.
NewConn is used to wrap a net.Conn that may be speaking the PROXY protocol
into a proxyproto.Conn.
NOTE: NewConn may interfere with previously set ReadDeadline on the provided net.Conn,
because it sets a temporary deadline when detecting and reading the PROXY protocol header.
If you need to enforce a specific ReadDeadline on the connection, be sure to call Conn.SetReadDeadline
again after NewConn returns, to restore your desired deadline.
Read identifies the proxy protocol version and reads the remaining of
the header, accordingly.
If proxy protocol header signature is not present, the reader buffer remains untouched
and is safe for reading outside of this code.
If proxy protocol header signature is present but an error is raised while processing
the remaining header, assume the reader buffer to be in a corrupt state.
Also, this operation will block until enough bytes are available for peeking.
ReadTimeout acts as Read but takes a timeout. If that timeout is reached, it's assumed
there's no proxy protocol header.
SetReadHeaderTimeout sets the readHeaderTimeout for a connection when passed as option to NewConn().
SkipProxyHeaderForCIDR returns a PolicyFunc which can be used to accept a
connection from a skipHeaderCIDR without requiring a PROXY header, e.g.
Kubernetes pods local traffic. The def is a policy to use when an upstream
address doesn't match the skipHeaderCIDR.
Deprecated: use ConnSkipProxyHeaderForCIDR instead.
SplitTLVs splits the Type-Length-Value vector, returns the vector or an error.
StrictWhiteListPolicy returns a PolicyFunc which decides whether the
upstream ip is allowed to send a proxy header based on a list of allowed
IP addresses and IP ranges. In case upstream IP is not in list reading on
the connection will be refused on the first read. Please note: subsequent
reads do not error. It is the task of the code using the connection to
handle that case properly. If one of the provided IP addresses or IP
ranges is invalid it will return an error instead of a PolicyFunc.
Deprecated: use ConnStrictWhiteListPolicy instead.
TrustProxyHeaderFrom returns a ConnPolicyFunc which can be used to decide
whether to use or reject PROXY headers based on the source IP of the
connection. This policy ensures that only trusted sources can set the PROXY
header. Connections from IPs not in the trusted list will be rejected.
ValidateHeader adds given validator for proxy headers to a connection when passed as option to NewConn().
WithBufferSize sets the size of the read buffer used for proxy header detection.
Values <= 0 are ignored and the default (256 bytes) is used. Values < 16 are
effectively 16 due to bufio's minimum. The default is tuned for typical proxy
protocol header lengths.
WithPolicy adds given policy to a connection when passed as option to NewConn().
Package-Level Variables (total 23)
DefaultReadHeaderTimeout is how long header processing waits for header to
be read from the wire, if Listener.ReaderHeaderTimeout is not set.
It's kept as a global variable so to make it easier to find and override,
e.g. go build -ldflags -X "github.com/pires/go-proxyproto.DefaultReadHeaderTimeout=1s".
ErrCantReadAddressFamilyAndProtocol indicates an address family and protocol could not be read.
ErrCantReadLength indicates a length could not be read.
ErrCantReadProtocolVersionAndCommand indicates a protocol version and command could not be read.
ErrCantReadVersion1Header indicates a v1 header could not be read.
ErrCantResolveDestinationUnixAddress indicates a destination Unix address could not be resolved.
ErrCantResolveSourceUnixAddress indicates a source Unix address could not be resolved.
ErrIncompatibleTLV indicates a TLV is of an unexpected type.
ErrInvalidAddress indicates an invalid address.
ErrInvalidLength indicates an invalid length.
ErrInvalidPortNumber indicates an invalid port number.
ErrInvalidUpstream should be returned when an upstream connection address
is not trusted, and therefore is invalid.
ErrLineMustEndWithCrlf indicates a v1 header is invalid, must end with \r\n.
ErrMalformedTLV indicates a TLV has malformed data.
ErrNoProxyProtocol indicates a proxy protocol signature is not present.
ErrSuperfluousProxyHeader indicates an upstream connection sent a PROXY header but isn't allowed to send one.
ErrTruncatedTLV indicates a TLV was truncated.
ErrUnknownProxyProtocolVersion indicates an unknown proxy protocol version.
ErrUnsupportedAddressFamilyAndProtocol indicates an unsupported address family and protocol.
ErrUnsupportedProtocolVersionAndCommand indicates an unsupported protocol version and command.
ErrVersion1HeaderTooLong indicates a v1 header is too long.
SIGV1 is the signature for PROXY protocol v1.
SIGV2 is the signature for PROXY protocol v2.
Package-Level Constants (total 35)
IGNORE address from PROXY header, but accept connection.
LOCAL represents the LOCAL command in v2 or UNKNOWN transport in v1,
in which case no address information is expected.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
Section 2.2.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
Section 2.2.7, reserved types.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
TLV type constants defined by the PROXY protocol spec.
PROXY represents the PROXY command in v2 or transport is not UNKNOWN in v1,
in which case valid local/remote address and port information is expected.
REJECT connection when PROXY header is sent
Note: even though the first read on the connection returns an error if
a PROXY header is present, subsequent reads do not. It is the task of
the code using the connection to handle that case properly.
REQUIRE connection to send PROXY header, reject if not present
Note: even though the first read on the connection returns an error if
a PROXY header is not present, subsequent reads do not. It is the task
of the code using the connection to handle that case properly.
SKIP accepts a connection without requiring the PROXY header.
Note: an example usage can be found in the SkipProxyHeaderForCIDR
function.
AddressFamilyAndProtocol enum values.
AddressFamilyAndProtocol enum values.
AddressFamilyAndProtocol enum values.
AddressFamilyAndProtocol enum values.
AddressFamilyAndProtocol enum values.
AddressFamilyAndProtocol enum values.
AddressFamilyAndProtocol enum values.
USE address from PROXY header.
 |
The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |