Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

rpc

package

Go to main page

Versions in this module

v1

v1.5.0

May 4, 2026

v1.4.9

Apr 28, 2026

v1.4.8

Apr 17, 2026

v1.4.7

Apr 3, 2026

Changes in this version

+ func WithPreferTLVersionFunc(ctx context.Context, f PreferTLVersionFunc) context.Context

+ type PreferTLVersionFunc = func(ctx context.Context, req *Request, defaultTLVersion int) int

+ func GetPreferTLVersionFunc(ctx context.Context) PreferTLVersionFunc

v1.4.6

Apr 2, 2026

v1.4.5

Apr 1, 2026

Changes in this version

+ func JoinSubnetsString(groups [][]string) string

+ func SplitSubnetsString(groups string) [][]string

v1.4.4

Mar 25, 2026

v1.4.3

Mar 24, 2026

v1.4.2

Mar 20, 2026

v1.4.1

Mar 20, 2026

v1.4.0

Mar 19, 2026

Changes in this version

+ const DefaultClientConnReadBufSize

+ const DefaultClientConnWriteBufSize

+ const DefaultConnTimeoutAccuracy

+ const DefaultMaxConns

+ const DefaultMaxWorkers

+ const DefaultPacketTimeout

+ const DefaultProtocolVersion

+ const DefaultRequestMemoryLimit

+ const DefaultResponseMemEstimate

+ const DefaultResponseMemoryLimit

+ const DefaultServerConnReadBufSize

+ const DefaultServerConnWriteBufSize

+ const DefaultServerRequestBufSize

+ const DefaultServerResponseBufSize

+ const FlagP2PHijack

+ const LatestProtocolVersion

+ const MinCryptoKeyLen

+ const PacketTypeRPCPing

+ const PacketTypeRPCPong

+ var ErrClientClosed = errors.New("rpc: Client closed")

+ var ErrClientConnClosedNoSideEffect = errors.New("rpc: client connection closed (or connect failed) before request sent")

+ var ErrClientConnClosedSideEffect = errors.New("rpc: client connection closed after request sent")

+ var ErrClientDropRequest = errors.New("rpc hook: drop request")

+ var ErrLongpollNoEmptyResponse = &Error

+ var ErrNoHandler = &Error

+ func ControlSetTCPReuse(addr bool, port bool) func(_ string, _ string, c syscall.RawConn) error

+ func EncryptionToString(schema int) string

+ func ErrorTag(err error) string

+ func GetExecutionContext(ctx context.Context) string

+ func GetTracingContext(ctx context.Context) tltracing.TraceContext

+ func HashSlice(key []byte) uint64

+ func HashString(key string) uint64

+ func IsLongpollResponse(err error) bool

+ func KeyIDFromCryptoKey(cryptoKey string) (keyID [4]byte)

+ func Listen(network, address string, disableTCPReuseAddr bool) (net.Listener, error)

+ func ListenUDP(network, address string) (*net.UDPConn, error)

+ func ListenUDPWildcard(host string, port uint16) ([]*net.UDPConn, error)

+ func NoopLogf(string, ...any)

+ func ParseTrustedSubnetGroupsFromString(groups string) (trustedSubnetGroups [][]*net.IPNet, errs []error)

+ func ParseTrustedSubnets(groups [][]string) (trustedSubnetGroups [][]*net.IPNet, errs []error)

+ func TraceIDToByteSlice(traceID TraceID, data []byte)

+ func TraceIDToString(traceID TraceID) string

+ func TrustedSubnetGroupsString(groups [][]string) string

+ func UpdateExtraTimeout(extra *RequestExtra, timeout time.Duration)

+ func WithExecutionContext(ctx context.Context, ec string) context.Context

+ func WithTracingContext(ctx context.Context, tc tltracing.TraceContext) context.Context

+ type CallbackContext struct

+ func (cc CallbackContext) QueryID() int64

+ type Client interface

+ Close func() error

+ Do func(ctx context.Context, network string, address string, req *Request) (*Response, error)

+ DoCallback func(ctx context.Context, network string, address string, req *Request, ...) (CallbackContext, error)

+ DoMulti func(ctx context.Context, addresses []NetAddr, ...) error

+ GetRequest func() *Request

+ Logf func(format string, args ...any)

+ Multi func(n int) *Multi

+ PutResponse func(cctx *Response)

+ ResetReconnectDelay func(address NetAddr)

+ func NewClient(options ...ClientOptionsFunc) Client

+ type ClientCallback func(client Client, resp *Response, err error)

+ type ClientHook interface

+ AfterSend func(resp *Response, err error)

+ BeforeSend func(ctx context.Context, addr NetAddr, req *Request) (context.Context, error)

+ type ClientImpl struct

+ func UnwrapClient(c Client) (*ClientImpl, bool)

+ func (c *ClientImpl) CancelDoCallback(cc CallbackContext) (cancelled bool)

+ func (c *ClientImpl) Close() error

+ func (c *ClientImpl) Do(ctx context.Context, network string, address string, req *Request) (*Response, error)

+ func (c *ClientImpl) DoCallback(ctx context.Context, network string, address string, req *Request, ...) (CallbackContext, error)

+ func (c *ClientImpl) DoMulti(ctx context.Context, addresses []NetAddr, ...) error

+ func (c *ClientImpl) GetLoad(address NetAddr) int

+ func (c *ClientImpl) GetRequest() *Request

+ func (c *ClientImpl) Logf(format string, args ...any)

+ func (c *ClientImpl) Multi(n int) *Multi

+ func (c *ClientImpl) PutResponse(cctx *Response)

+ func (c *ClientImpl) ResetReconnectDelay(address NetAddr)

+ type ClientOptions struct

+ ConnReadBufSize int

+ ConnWriteBufSize int

+ CryptoKey string

+ DebugUdp int

+ DefaultTimeout time.Duration

+ ForceEncryption bool

+ HookMaker func() ClientHook

+ Logf LoggerFunc

+ MaxReconnectDelay time.Duration

+ PacketTimeout time.Duration

+ PrintKeysGenerationInfo bool

+ ProtocolVersion uint32

+ TracingInject TracingInjectFunc

+ TrustedSubnetGroups [][]*net.IPNet

+ type ClientOptionsFunc func(*ClientOptions)

+ func ClientWithConnReadBufSize(size int) ClientOptionsFunc

+ func ClientWithConnWriteBufSize(size int) ClientOptionsFunc

+ func ClientWithCryptoKey(key string) ClientOptionsFunc

+ func ClientWithDebugBeforeSendHookLatencyHandler(h LatencyHandler) ClientOptionsFunc

+ func ClientWithDebugProxyLatencyHandler(h LatencyHandler) ClientOptionsFunc

+ func ClientWithDebugReceiveLatencyHandler(h LatencyHandler) ClientOptionsFunc

+ func ClientWithDebugSendLatencyHandler(h LatencyHandler) ClientOptionsFunc

+ func ClientWithDebugUdp(DebugUdp int) ClientOptionsFunc

+ func ClientWithExperimentalLocalUDPAddress(localUDPAddress string) ClientOptionsFunc

+ func ClientWithForceEncryption(force bool) ClientOptionsFunc

+ func ClientWithHooks(hookMaker func() ClientHook) ClientOptionsFunc

+ func ClientWithLogf(f LoggerFunc) ClientOptionsFunc

+ func ClientWithMaxReconnectDelay(delay time.Duration) ClientOptionsFunc

+ func ClientWithPacketTimeout(timeout time.Duration) ClientOptionsFunc

+ func ClientWithProtocolVersion(protocolVersion uint32) ClientOptionsFunc

+ func ClientWithTracingInject(inject TracingInjectFunc) ClientOptionsFunc

+ func ClientWithTrustedSubnetGroups(groups [][]string) ClientOptionsFunc

+ type ClientUnwrapper interface

+ Unwrap func() Client

+ type ClusterClient struct

+ func NewClusterClient(client Client, opts ...ClusterClientOptionsFunc) *ClusterClient

+ func (cc *ClusterClient) DoAll(ctx context.Context, write bool, ...) error

+ func (cc *ClusterClient) DoAny(ctx context.Context, write bool, req *Request) (*Response, error)

+ func (cc *ClusterClient) DoKey(ctx context.Context, write bool, req *Request, key uint64) (*Response, error)

+ func (cc *ClusterClient) RPCClient() Client

+ func (cc *ClusterClient) SelectAll(write bool) []NetAddr

+ func (cc *ClusterClient) SelectAny(write bool) NetAddr

+ func (cc *ClusterClient) SelectKey(write bool, key uint64) NetAddr

+ func (cc *ClusterClient) UpdateCluster(shards []ClusterShard) error

+ type ClusterClientOptions struct

+ BigCluster bool

+ OnDo func(addr NetAddr, req *Request)

+ ShardSelectKeyModulo bool

+ type ClusterClientOptionsFunc func(*ClusterClientOptions)

+ func ClusterClientWithBigCluster(v bool) ClusterClientOptionsFunc

+ func ClusterClientWithOnDo(v func(addr NetAddr, req *Request)) ClusterClientOptionsFunc

+ func ClusterClientWithShardSelectKeyModulo(v bool) ClusterClientOptionsFunc

+ type ClusterShard struct

+ Name string

+ ReadNodes []NetAddr

+ WriteNodes []NetAddr

+ type EncHeader = tlnetUdpPacket.EncHeader

+ type ErrHandlerFunc func(err error)

+ type Error struct

+ Code int32

+ Description string

+ func NewDefaultError(description string) *Error

+ func NewError(code int32, description string) *Error

+ func (err *Error) Error() string

+ func (err *Error) IsApplicationLevelError() bool

+ type ForwardPacketResult struct

+ ClientWantsFin bool

+ ServerWantsFin bool

+ func ForwardPacket(dst, src *PacketConn, copyBodyBuf []byte, opt forwardPacketOptions) (res ForwardPacketResult)

+ func (p ForwardPacketResult) String() string

+ type ForwardPacketsResult struct

+ ClientWantsFin bool

+ ServerWantsFin bool

+ func ForwardPackets(ctx context.Context, dst, src *PacketConn) ForwardPacketsResult

+ func (res ForwardPacketsResult) String() string

+ type HandlerContext struct

+ Request []byte

+ RequestExtra RequestExtra

+ Response []byte

+ ResponseExtra ResponseExtra

+ UserData any

+ func GetHandlerContext(ctx context.Context) *HandlerContext

+ func (hctx *HandlerContext) AccountResponseMem(respBodySizeEstimate int) error

+ func (hctx *HandlerContext) ActorID() int64

+ func (hctx *HandlerContext) BodyFormatTL2() bool

+ func (hctx *HandlerContext) ForwardAndFlush(conn *PacketConn, tip uint32, timeout time.Duration) error

+ func (hctx *HandlerContext) KeyID() [4]byte

+ func (hctx *HandlerContext) ListenAddr() net.Addr

+ func (hctx *HandlerContext) LocalAddr() net.Addr

+ func (hctx *HandlerContext) LongpollStarted() bool

+ func (hctx *HandlerContext) ParseInvokeReq(opts *ServerOptions) (err error)

+ func (hctx *HandlerContext) PrepareResponse(err error) (extraStart int)

+ func (hctx *HandlerContext) ProtocolTransport() string

+ func (hctx *HandlerContext) ProtocolVersion() uint32

+ func (hctx *HandlerContext) QueryID() int64

+ func (hctx *HandlerContext) RemoteAddr() net.Addr

+ func (hctx *HandlerContext) RequestFunctionName() string

+ func (hctx *HandlerContext) RequestTag() uint32

+ func (hctx *HandlerContext) RequestTime() time.Time

+ func (hctx *HandlerContext) ResetTo(commonConn HandlerContextConnection, queryID int64)

+ func (hctx *HandlerContext) SendLongpollResponse(err error)

+ func (hctx *HandlerContext) SetRequestFunctionName(name string)

+ func (hctx *HandlerContext) StartLongpoll(canceller LongpollCanceller) (LongpollHandle, error)

+ func (hctx *HandlerContext) StartLongpollWithTimeoutDeprecated(canceller LongpollCanceller, timeout time.Duration) (LongpollHandle, error)

+ func (hctx *HandlerContext) TraceIDStr() string

+ func (hctx *HandlerContext) WithContext(ctx context.Context) context.Context

+ func (hctx *HandlerContext) WriteReponseAndFlush(conn *PacketConn, err error) error

+ type HandlerContextConnection interface

+ AccountResponseMem func(hctx *HandlerContext, respBodySizeEstimate int) error

+ CancelLongpoll func(queryID int64) (_ LongpollCanceller, deadline int64)

+ ConnectionID func() uintptr

+ DebugName func() string

+ FinishLongpoll func(LongpollHandle) (*HandlerContext, error)

+ KeyID func() [4]byte

+ ListenAddr func() net.Addr

+ LocalAddr func() net.Addr

+ ProtocolTransportID func() byte

+ ProtocolVersion func() uint32

+ RemoteAddr func() net.Addr

+ SendEmptyResponse func(lh LongpollHandle)

+ SendResponse func(hctx *HandlerContext, err error)

+ StartLongpoll func(hctx *HandlerContext, canceller LongpollCanceller) (LongpollHandle, error)

+ type HandlerFunc func(ctx context.Context, hctx *HandlerContext) error

+ func ChainHandler(ff ...HandlerFunc) HandlerFunc

+ type HijackConnection struct

+ Magic []byte

+ func (h *HijackConnection) LooksLikeHTTP() bool

+ func (h *HijackConnection) Read(p []byte) (int, error)

+ type HijackListener struct

+ ListenAddr net.Addr

+ func NewHijackListener(listenAddr net.Addr) *HijackListener

+ func (h *HijackListener) Accept() (net.Conn, error)

+ func (h *HijackListener) AddConnection(conn net.Conn)

+ func (h *HijackListener) Addr() net.Addr

+ func (h *HijackListener) Close() error

+ type InvokeReqExtra struct

+ FailIfNoConnection bool

+ PreferTL2 bool

+ PreferTLVersion int

+ ResponseExtra ResponseExtra

+ type LatencyHandler func(duration time.Duration)

+ type LoggerFunc func(format string, args ...any)

+ type LongpollCanceller interface

+ CancelLongpoll func(lh LongpollHandle)

+ WriteEmptyResponse func(lh LongpollHandle, resp *HandlerContext) error

+ type LongpollHandle struct

+ CommonConn HandlerContextConnection

+ QueryID int64

+ func (lh *LongpollHandle) FinishLongpoll() (*HandlerContext, bool)

+ type Multi struct

+ func (m *Multi) Client() Client

+ func (m *Multi) Close()

+ func (m *Multi) Start(ctx context.Context, network string, address string, req *Request) error

+ func (m *Multi) Wait(ctx context.Context, queryID int64) (*Response, error)

+ func (m *Multi) WaitAny(ctx context.Context) (int64, *Response, error)

+ type NetAddr struct

+ Address string

+ Network string

+ func (na NetAddr) String() string

+ type NetPID = tlnet.Pid

+ type PacketConn struct

+ func NewDefaultPacketConn(c net.Conn) *PacketConn

+ func NewPacketConn(c net.Conn, readBufSize int, writeBufSize int) *PacketConn

+ func (pc *PacketConn) Close() error

+ func (pc *PacketConn) Encrypted() bool

+ func (pc *PacketConn) FlagCancelReq() bool

+ func (pc *PacketConn) Flush() error

+ func (pc *PacketConn) FlushUnlocked() error

+ func (pc *PacketConn) HandshakeClient(cryptoKey string, trustedSubnetGroups [][]*net.IPNet, forceEncryption bool, ...) error

+ func (pc *PacketConn) HandshakeServer(cryptoKeys []string, trustedSubnetGroups [][]*net.IPNet, forceEncryption bool, ...) ([]byte, uint32, error)

+ func (pc *PacketConn) HijackConnection() (net.Conn, []byte)

+ func (pc *PacketConn) KeyID() [4]byte

+ func (pc *PacketConn) LocalAddr() net.Addr

+ func (pc *PacketConn) ProtocolVersion() uint32

+ func (pc *PacketConn) ReadPacket(body []byte, timeout time.Duration) (tip uint32, _ []byte, err error)

+ func (pc *PacketConn) ReadPacketBodyUnlocked(header *packetHeader, body []byte) (_ []byte, err error)

+ func (pc *PacketConn) ReadPacketHeaderUnlocked(header *packetHeader, timeout time.Duration) (magicHead []byte, isBuiltin bool, builtinKind string, err error)

+ func (pc *PacketConn) ReadPacketUnlocked(body []byte, timeout time.Duration) (tip uint32, _ []byte, isBuiltin bool, builtinKind string, err error)

+ func (pc *PacketConn) RemoteAddr() net.Addr

+ func (pc *PacketConn) SetReadTimeoutUnlocked(timeout time.Duration) error

+ func (pc *PacketConn) SetWriteTimeoutUnlocked(timeout time.Duration) error

+ func (pc *PacketConn) ShutdownWrite() error

+ func (pc *PacketConn) TCPSetsockoptInt(level int, opt int, value int) error

+ func (pc *PacketConn) WritePacket(packetType uint32, body []byte, timeout time.Duration) error

+ func (pc *PacketConn) WritePacket2(packetType uint32, body []byte, body2 []byte, timeout time.Duration) error

+ func (pc *PacketConn) WritePacketBodyUnlocked(body []byte) error

+ func (pc *PacketConn) WritePacketBuiltin(timeout time.Duration) error

+ func (pc *PacketConn) WritePacketBuiltinNoFlushUnlocked(timeout time.Duration) error

+ func (pc *PacketConn) WritePacketHeaderUnlocked(packetType uint32, packetBodyLen int, timeout time.Duration) error

+ func (pc *PacketConn) WritePacketNoFlush(packetType uint32, body []byte, timeout time.Duration) error

+ func (pc *PacketConn) WritePacketNoFlushUnlocked(packetType uint32, body []byte, timeout time.Duration) error

+ func (pc *PacketConn) WritePacketTrailerUnlocked()

+ func (pc *PacketConn) WriteRawBytes(b []byte) (int, error)

+ type PacketHeaderCircularBuffer struct

+ func (b *PacketHeaderCircularBuffer) String() string

+ type ReadWriteError struct

+ ReadErr error

+ WriteErr error

+ func (r ReadWriteError) Error() error

+ type Request struct

+ ActorID int64

+ Body []byte

+ BodyFormatTL2 bool

+ Extra RequestExtra

+ FailIfNoConnection bool

+ FunctionName string

+ ReadOnly bool

+ func (req *Request) QueryID() int64

+ type RequestExtra = tl.RpcInvokeReqExtra

+ type RequestHookFunc func(hctx *HandlerContext, ctx context.Context) context.Context

+ type Response struct

+ Body []byte

+ Extra ResponseExtra

+ func (resp *Response) BodyFormatTL2() bool

+ func (resp *Response) QueryID() int64

+ func (resp *Response) UserData() any

+ type ResponseExtra = tl.RpcReqResultExtra

+ type ResponseHookFunc func(hctx *HandlerContext, err error)

+ type Server struct

+ func NewServer(options ...ServerOptionsFunc) *Server

+ func (s *Server) Close() error

+ func (s *Server) CloseWait(ctx context.Context) error

+ func (s *Server) CollectStats(localAddr net.Addr) map[string]string

+ func (s *Server) ConnectionsCurrent() int64

+ func (s *Server) ConnectionsTCPCurrent() int64

+ func (s *Server) ConnectionsTCPTotal() int64

+ func (s *Server) ConnectionsTotal() int64

+ func (s *Server) ConnectionsUDPCurrent() int64

+ func (s *Server) ConnectionsUDPTotal() int64

+ func (s *Server) GetCryptoKeys() []string

+ func (s *Server) ListenAndServe(network string, address string) error

+ func (s *Server) LongPollsWaiting() int64

+ func (s *Server) RPS() int64

+ func (s *Server) RegisterHandlerFunc(h HandlerFunc)

+ func (s *Server) RegisterStatsHandlerFunc(h StatsHandlerFunc)

+ func (s *Server) RegisterVerbosityHandlerFunc(h VerbosityHandlerFunc)

+ func (s *Server) RequestsCurrent() int64

+ func (s *Server) RequestsMemory() (current int64, total int64)

+ func (s *Server) RequestsTotal() int64

+ func (s *Server) ResponsesMemory() (current int64, total int64)

+ func (s *Server) Serve(ln net.Listener) error

+ func (s *Server) ServeUDP(conn *net.UDPConn) error

+ func (s *Server) SetEngineShutdownStatus(engineShutdown bool)

+ func (s *Server) Shutdown()

+ func (s *Server) WorkersPoolSize() (current int, total int)

+ type ServerOptions struct

+ AcceptErrHandler ErrHandlerFunc

+ ConnErrHandler ErrHandlerFunc

+ ConnReadBufSize int

+ ConnWriteBufSize int

+ DebugRPC bool

+ DebugUDPLatency bool

+ DebugUdpRPC int

+ DefaultResponseTimeout time.Duration

+ DisableContextTimeout bool

+ DisableTCPReuseAddr bool

+ ForceEncryption bool

+ Handler HandlerFunc

+ Logf LoggerFunc

+ MaxConns int

+ MaxWorkers int

+ MinimumLongpollTimeout time.Duration

+ PrintKeysGenerationInfo bool

+ RecoverPanics bool

+ RequestBufSize int

+ RequestHook RequestHookFunc

+ RequestMemoryLimit int

+ ResponseBufSize int

+ ResponseHook ResponseHookFunc

+ ResponseMemEstimate int

+ ResponseMemoryLimit int

+ SocketHijackHandler func(conn *HijackConnection)

+ StatsHandler StatsHandlerFunc

+ SyncHandler HandlerFunc

+ TransportHijackHandler func(conn *PacketConn)

+ TrustedSubnetGroups [][]*net.IPNet

+ TrustedSubnetGroupsSt string

+ VerbosityHandler VerbosityHandlerFunc

+ Version string

+ func (opts *ServerOptions) AddCryptoKey(key string)

+ type ServerOptionsFunc func(*ServerOptions)

+ func ServerWithAcceptErrorHandler(fn ErrHandlerFunc) ServerOptionsFunc

+ func ServerWithConnErrorHandler(fn ErrHandlerFunc) ServerOptionsFunc

+ func ServerWithConnReadBufSize(size int) ServerOptionsFunc

+ func ServerWithConnWriteBufSize(size int) ServerOptionsFunc

+ func ServerWithCryptoKeys(keys []string) ServerOptionsFunc

+ func ServerWithDebugRPC(debugRpc bool) ServerOptionsFunc

+ func ServerWithDebugUDPLatency(debugUDPLatency bool) ServerOptionsFunc

+ func ServerWithDebugUdpRPC(debugUdpRpc int) ServerOptionsFunc

+ func ServerWithDefaultResponseTimeout(timeout time.Duration) ServerOptionsFunc

+ func ServerWithDisableContextTimeout(status bool) ServerOptionsFunc

+ func ServerWithDisableTCPReuseAddr() ServerOptionsFunc

+ func ServerWithForceEncryption(status bool) ServerOptionsFunc

+ func ServerWithHandler(handler HandlerFunc) ServerOptionsFunc

+ func ServerWithLogf(logf LoggerFunc) ServerOptionsFunc

+ func ServerWithMaxConns(maxConns int) ServerOptionsFunc

+ func ServerWithMaxWorkers(maxWorkers int) ServerOptionsFunc

+ func ServerWithMinimumLongpollTimeout(timeout time.Duration) ServerOptionsFunc

+ func ServerWithPrintKeysGenerationInfo(printKeysGenerationInfo bool) ServerOptionsFunc

+ func ServerWithRecoverPanics(recoverPanics bool) ServerOptionsFunc

+ func ServerWithRequestBufSize(size int) ServerOptionsFunc

+ func ServerWithRequestHook(fn RequestHookFunc) ServerOptionsFunc

+ func ServerWithRequestMemoryLimit(limit int) ServerOptionsFunc

+ func ServerWithResponseBufSize(size int) ServerOptionsFunc

+ func ServerWithResponseHook(fn ResponseHookFunc) ServerOptionsFunc

+ func ServerWithResponseMemEstimate(size int) ServerOptionsFunc

+ func ServerWithResponseMemoryLimit(limit int) ServerOptionsFunc

+ func ServerWithSocketHijackHandler(handler func(conn *HijackConnection)) ServerOptionsFunc

+ func ServerWithStatsHandler(handler StatsHandlerFunc) ServerOptionsFunc

+ func ServerWithSyncHandler(syncHandler HandlerFunc) ServerOptionsFunc

+ func ServerWithTransportHijackHandler(handler func(conn *PacketConn)) ServerOptionsFunc

+ func ServerWithTrustedSubnetGroups(groups [][]string) ServerOptionsFunc

+ func ServerWithUDPReadScheduleLatencyMetric(readScheduleLatencyMetric func(millis float64)) ServerOptionsFunc

+ func ServerWithUDPSocketReadLatencyMetric(socketReadLatencyMetric func(millis float64)) ServerOptionsFunc

+ func ServerWithUDPSocketWriteLatencyMetric(socketWriteLatencyMetric func(millis float64)) ServerOptionsFunc

+ func ServerWithUDPWriteScheduleLatencyMetric(writeScheduleLatencyMetric func(millis float64)) ServerOptionsFunc

+ func ServerWithVerbosityHandler(handler VerbosityHandlerFunc) ServerOptionsFunc

+ func ServerWithVersion(version string) ServerOptionsFunc

+ type StatsHandlerFunc func(map[string]string)

+ type TargetError struct

+ Address NetAddr

+ Err error

+ func (err TargetError) Error() string

+ func (err TargetError) Unwrap() error

+ type TraceContext = tltracing.TraceContext

+ type TraceID = tltracing.TraceID

+ func TraceIDFromByteSlice(data []byte) TraceID

+ func TraceIDFromString(str string) (TraceID, error)

+ type TraceStatus = int

+ var TraceStatusDefer TraceStatus = 2

+ var TraceStatusDrop TraceStatus = 0

+ var TraceStatusRecord TraceStatus = 1

+ func GetTraceStatus(tc *TraceContext) TraceStatus

+ type TracingInjectFunc func(ctx context.Context, tc *TraceContext)

+ type UdpServerConn struct

+ func (sc *UdpServerConn) AccountResponseMem(hctx *HandlerContext, respBodySizeEstimate int) (err error)

+ func (sc *UdpServerConn) CancelLongpoll(queryID int64) (LongpollCanceller, int64)

+ func (sc *UdpServerConn) ConnectionID() uintptr

+ func (sc *UdpServerConn) DebugName() string

+ func (sc *UdpServerConn) FinishLongpoll(lh LongpollHandle) (*HandlerContext, error)

+ func (sc *UdpServerConn) KeyID() [4]byte

+ func (sc *UdpServerConn) ListenAddr() net.Addr

+ func (sc *UdpServerConn) LocalAddr() net.Addr

+ func (sc *UdpServerConn) ProtocolTransportID() byte

+ func (sc *UdpServerConn) ProtocolVersion() uint32

+ func (sc *UdpServerConn) RemoteAddr() net.Addr

+ func (sc *UdpServerConn) SendEmptyResponse(lh LongpollHandle)

+ func (sc *UdpServerConn) SendResponse(hctx *HandlerContext, err error)

+ func (sc *UdpServerConn) StartLongpoll(hctx *HandlerContext, canceller LongpollCanceller) (LongpollHandle, error)

+ type UnencHeader = tlnetUdpPacket.UnencHeader

+ type VerbosityHandlerFunc func(int) error