MagiTrickle/pkg/dns-proxy/dns-proxy.go

120 lines
2.4 KiB
Go
Raw Normal View History

2024-08-24 17:46:34 +03:00
package dnsProxy
import (
2024-08-25 01:43:44 +03:00
"context"
2024-08-30 03:58:36 +03:00
"errors"
2024-08-24 17:46:34 +03:00
"fmt"
"net"
2024-08-30 03:58:36 +03:00
"os"
2024-08-24 17:46:34 +03:00
"time"
2024-09-04 09:15:03 +03:00
"github.com/rs/zerolog/log"
2024-08-24 17:46:34 +03:00
)
const (
DNSMaxUDPPackageSize = 4096
)
type DNSProxy struct {
2024-08-25 01:43:44 +03:00
udpConn *net.UDPConn
listenPort uint16
2024-08-24 17:46:34 +03:00
2024-08-25 01:43:44 +03:00
targetDNSServerAddress string
2024-08-24 17:46:34 +03:00
MsgHandler func(*Message)
}
2024-08-25 01:43:44 +03:00
func (p DNSProxy) Listen(ctx context.Context) error {
var err error
2024-08-24 21:26:49 +03:00
2024-08-25 01:43:44 +03:00
udpAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", p.listenPort))
2024-08-24 21:26:49 +03:00
if err != nil {
2024-08-25 01:43:44 +03:00
return fmt.Errorf("failed to resolve UDP address: %v", err)
2024-08-24 21:26:49 +03:00
}
2024-08-25 01:43:44 +03:00
p.udpConn, err = net.ListenUDP("udp", udpAddr)
2024-08-24 21:26:49 +03:00
if err != nil {
2024-08-25 01:43:44 +03:00
return fmt.Errorf("failed to listen UDP address: %v", err)
2024-08-24 21:26:49 +03:00
}
2024-08-25 01:43:44 +03:00
defer func() {
if p.udpConn != nil {
err := p.udpConn.Close()
if err != nil {
2024-09-04 09:15:03 +03:00
log.Error().Err(err).Msg("failed to close UDP connection")
2024-08-25 01:43:44 +03:00
}
}
}()
2024-08-24 17:46:34 +03:00
2024-08-25 01:43:44 +03:00
for {
select {
case <-ctx.Done():
return nil
default:
buffer := make([]byte, DNSMaxUDPPackageSize)
n, clientAddr, err := p.udpConn.ReadFromUDP(buffer)
if err != nil {
2024-09-04 09:15:03 +03:00
log.Error().Err(err).Msg("failed to read UDP packet")
2024-08-25 01:43:44 +03:00
continue
}
go p.handleDNSRequest(clientAddr, buffer[:n])
}
2024-08-24 17:46:34 +03:00
}
2024-08-25 01:43:44 +03:00
}
2024-08-24 17:46:34 +03:00
2024-08-25 01:43:44 +03:00
func (p DNSProxy) handleDNSRequest(clientAddr *net.UDPAddr, buffer []byte) {
conn, err := net.Dial("udp", p.targetDNSServerAddress)
2024-08-24 17:46:34 +03:00
if err != nil {
2024-09-04 09:15:03 +03:00
log.Error().Err(err).Msg("failed to dial target DNS")
2024-08-25 01:43:44 +03:00
return
2024-08-24 17:46:34 +03:00
}
defer conn.Close()
2024-08-25 01:43:44 +03:00
_, err = conn.Write(buffer)
2024-08-24 17:46:34 +03:00
if err != nil {
2024-09-04 09:15:03 +03:00
log.Error().Err(err).Msg("failed to send request to target DNS")
2024-08-25 01:43:44 +03:00
return
2024-08-24 17:46:34 +03:00
}
err = conn.SetReadDeadline(time.Now().Add(5 * time.Second))
if err != nil {
2024-09-04 09:15:03 +03:00
log.Error().Err(err).Msg("failed to set read deadline")
2024-08-25 01:43:44 +03:00
return
2024-08-24 17:46:34 +03:00
}
2024-08-25 01:43:44 +03:00
response := make([]byte, DNSMaxUDPPackageSize)
2024-08-24 17:46:34 +03:00
n, err := conn.Read(response)
if err != nil {
2024-08-30 03:58:36 +03:00
if errors.Is(err, os.ErrDeadlineExceeded) {
// Just skip it
return
}
2024-09-04 09:15:03 +03:00
log.Error().Err(err).Msg("failed to read response from target DNS")
2024-08-24 17:46:34 +03:00
return
}
2024-08-25 01:43:44 +03:00
msg, err := ParseResponse(response[:n])
2024-08-24 17:46:34 +03:00
if err == nil {
if p.MsgHandler != nil {
p.MsgHandler(msg)
}
} else {
2024-09-04 09:15:03 +03:00
log.Warn().Err(err).Msg("error while parsing DNS message")
2024-08-24 21:26:49 +03:00
}
2024-08-25 01:43:44 +03:00
_, err = p.udpConn.WriteToUDP(response[:n], clientAddr)
2024-08-24 17:46:34 +03:00
if err != nil {
2024-09-04 09:15:03 +03:00
log.Error().Err(err).Msg("failed to send DNS message")
2024-08-25 01:43:44 +03:00
return
2024-08-24 17:46:34 +03:00
}
}
2024-08-25 01:43:44 +03:00
func New(listenPort uint16, targetDNSServerAddress string) *DNSProxy {
2024-08-24 17:46:34 +03:00
return &DNSProxy{
2024-08-25 01:43:44 +03:00
listenPort: listenPort,
targetDNSServerAddress: targetDNSServerAddress,
2024-08-24 17:46:34 +03:00
}
}