server

type CallbackEvent struct {
	// Type is the type of callback event
	Type CallbackType

	// ConnectionID is the connection identifier (if applicable)
	ConnectionID string

	// StreamID is the stream identifier (if applicable)
	StreamID int64

	// PeerAddr is the peer address (DNS client)
	PeerAddr *net.UDPAddr

	// UpstreamAddr is the upstream address
	UpstreamAddr net.Addr

	// Data is the event data (if applicable)
	Data []byte

	// ByteCount is the number of bytes transferred
	ByteCount int

	// Error is the error (if applicable)
	Error error

	// Context provides additional context
	Context context.Context
}

type CallbackHandler func(event *CallbackEvent)

type CallbackRegistry struct {
	// contains filtered or unexported fields
}

type CallbackType int

type Config struct {
	// DNSListenPort is the UDP port to listen for DNS queries on
	// Default: 53
	DNSListenPort int

	// DNSListenAddr is the address to bind the DNS listener to
	// Default: "0.0.0.0" (all interfaces)
	DNSListenAddr string

	// ListenIPv6 enables IPv6 listening in addition to IPv4
	// Default: false
	ListenIPv6 bool

	// TargetAddress is the address of the upstream TCP service to forward to
	// Example: "127.0.0.1:8080"
	TargetAddress string

	// Domain is the base domain used for DNS tunneling
	// All DNS queries must be for subdomains of this domain
	Domain string

	// CertFile is the path to the TLS certificate file
	CertFile string

	// KeyFile is the path to the TLS private key file
	KeyFile string

	// TLSConfig is an optional pre-configured TLS configuration
	// If provided, CertFile and KeyFile are ignored
	TLSConfig *tls.Config

	// MaxConnections is the maximum number of concurrent QUIC connections
	// Default: 1000
	MaxConnections int

	// MaxStreamsPerConnection is the maximum number of streams per connection
	// Default: 100
	MaxStreamsPerConnection int

	// IdleTimeout is the connection idle timeout
	// Default: 30s
	IdleTimeout time.Duration

	// ReadTimeout is the timeout for reading from upstream TCP connections
	// Default: 30s
	ReadTimeout time.Duration

	// WriteTimeout is the timeout for writing to upstream TCP connections
	// Default: 30s
	WriteTimeout time.Duration

	// UpstreamConnectTimeout is the timeout for connecting to upstream TCP services
	// Default: 10s
	UpstreamConnectTimeout time.Duration

	// BufferSize is the buffer size for data transfer
	// Default: 32KB
	BufferSize int

	// EnableLogging enables debug logging
	// Default: false
	EnableLogging bool
}

type Connection struct {
	// ID is the unique connection identifier
	ID string

	// PeerAddr is the client's address
	PeerAddr *net.UDPAddr
	// contains filtered or unexported fields
}

type ConnectionCallback struct {
	// OnStreamOpened is called when a stream is opened on this connection
	OnStreamOpened func(streamID int64)

	// OnStreamClosed is called when a stream is closed on this connection
	OnStreamClosed func(streamID int64)

	// OnStreamData is called when data is received on a stream
	OnStreamData func(streamID int64, data []byte)

	// OnConnectionClosed is called when this connection is closed
	OnConnectionClosed func()

	// OnError is called when an error occurs on this connection
	OnError func(err error)
}

type ConnectionCallbackHandler struct {
	// contains filtered or unexported fields
}

type ConnectionCallbackRegistry struct {
	// contains filtered or unexported fields
}

type ConnectionManager struct {
	// contains filtered or unexported fields
}

type ConnectionState int32

type IOCopier struct {
	// contains filtered or unexported fields
}

type IOCopierConfig struct {
	// BufferSize is the copy buffer size
	BufferSize int

	// FlushInterval is how often to flush pending data
	FlushInterval time.Duration
}

type IOCopierStats struct {
	BytesCopiedUp   uint64
	BytesCopiedDown uint64
}

type Server struct {
	// contains filtered or unexported fields
}

type ServerCallbacks struct {
	// OnServerStarted is called when the server starts
	OnServerStarted func()

	// OnServerStopped is called when the server stops
	OnServerStopped func(error)

	// OnConnectionAccepted is called when a new QUIC connection is accepted
	OnConnectionAccepted func(connectionID string, peerAddr *net.UDPAddr)

	// OnConnectionClosed is called when a QUIC connection is closed
	OnConnectionClosed func(connectionID string)

	// OnStreamOpened is called when a new stream is opened
	OnStreamOpened func(connectionID string, streamID int64)

	// OnStreamClosed is called when a stream is closed
	OnStreamClosed func(connectionID string, streamID int64)

	// OnStreamData is called when data is received on a stream
	OnStreamData func(connectionID string, streamID int64, data []byte)

	// OnUpstreamConnected is called when upstream connection is established
	OnUpstreamConnected func(connectionID string, streamID int64, addr net.Addr)

	// OnUpstreamDisconnected is called when upstream connection is closed
	OnUpstreamDisconnected func(connectionID string, streamID int64)

	// OnQueryReceived is called when a DNS query is received
	OnQueryReceived func(peerAddr *net.UDPAddr, queryLen int)

	// OnResponseSent is called when a DNS response is sent
	OnResponseSent func(peerAddr *net.UDPAddr, responseLen int)

	// OnError is called when an error occurs
	OnError func(err error)
}

type ServerState int32

type ServerStats struct {
	// Connection stats
	ConnectionsAccepted uint64
	ConnectionsActive   uint64
	ConnectionsClosed   uint64

	// Stream stats
	StreamsOpened uint64
	StreamsClosed uint64

	// Data stats
	QueriesReceived   uint64
	ResponsesSent     uint64
	BytesFromClients  uint64
	BytesToClients    uint64
	BytesFromUpstream uint64
	BytesToUpstream   uint64

	// Error stats
	Errors uint64

	// Timing
	StartedAt      time.Time
	LastActivityAt time.Time
}

type Stream struct {
	// ID is the unique stream identifier (QUIC stream ID)
	ID int64

	// ConnectionID is the ID of the parent connection
	ConnectionID string

	// Upstream is the TCP connection to the upstream service
	Upstream *UpstreamConnection
	// contains filtered or unexported fields
}

type StreamConfig struct {
	// BufferSize is the size of read/write buffers
	BufferSize int

	// IncomingQueueSize is the size of the incoming data queue
	IncomingQueueSize int

	// OutgoingQueueSize is the size of the outgoing data queue
	OutgoingQueueSize int

	// DrainingTimeout is the maximum time to wait while draining outgoing data
	DrainingTimeout time.Duration
}

type StreamManager struct {
	// contains filtered or unexported fields
}

type StreamManagerStats struct {
	TotalStreams      uint64
	ActiveStreams     uint64
	ClosedStreams     uint64
	TotalBytesIn      uint64
	TotalBytesOut     uint64
	StreamsByConnSize int
}

type StreamState int32

type StreamStats struct {
	ID              int64
	ConnectionID    string
	State           StreamState
	CreatedAt       time.Time
	LastActivity    time.Time
	BytesFromClient uint64
	BytesToClient   uint64
}

type UpstreamConfig struct {
	// TargetAddress is the address to connect to
	TargetAddress string

	// ConnectTimeout is the timeout for establishing the connection
	ConnectTimeout time.Duration

	// ReadTimeout is the timeout for read operations
	ReadTimeout time.Duration

	// WriteTimeout is the timeout for write operations
	WriteTimeout time.Duration

	// KeepAlive enables TCP keep-alive
	KeepAlive bool

	// KeepAliveInterval is the keep-alive probe interval
	KeepAliveInterval time.Duration
}

type UpstreamConnection struct {
	// contains filtered or unexported fields
}

type UpstreamConnectionState int32

type UpstreamManager struct {
	// contains filtered or unexported fields
}

type UpstreamManagerStats struct {
	TotalConnections  uint64
	ActiveConnections uint64
	ClosedConnections uint64
	TotalBytesRead    uint64
	TotalBytesWritten uint64
	ConnectFailures   uint64
}

type UpstreamStats struct {
	StreamID     int64
	ConnectionID string
	TargetAddr   string
	State        UpstreamConnectionState
	BytesRead    uint64
	BytesWritten uint64
	CreatedAt    time.Time
	LastActivity time.Time
}