udp relay example

udprelay.go

package main

import (
	"bytes"
	"flag"
	"log"
	"net"
	"sync"
	"time"
)

const (
	udpTimeout = 30 * time.Second
)

var (
	natlist = newNatTable()
)

type natTable struct {
	sync.Mutex
	conns map[string]*net.UDPConn
}

func newNatTable() *natTable {
	return &natTable{conns: map[string]*net.UDPConn{}}
}

func (table *natTable) Delete(index string) *net.UDPConn {
	table.Lock()
	defer table.Unlock()

	c, ok := table.conns[index]
	if ok {
		delete(table.conns, index)
		log.Printf("--- delete nat %s -> %s", index, c.LocalAddr().String())
		return c
	}
	return nil
}

func (table *natTable) Get(index string) (c *net.UDPConn, ok bool, err error) {
	table.Lock()
	defer table.Unlock()
	c, ok = table.conns[index]
	if !ok {
		c, err = net.ListenUDP("udp", &net.UDPAddr{
			IP:   net.IPv4zero,
			Port: 0,
		})
		if err != nil {
			return
		}
		table.conns[index] = c
		log.Printf("+++ create nat %s -> %s", index, c.LocalAddr().String())
	}
	return
}

func pipe(handle *net.UDPConn, src *net.UDPAddr, remote *net.UDPConn) {
	buf := make([]byte, 4096)
	for {
		n, raddr, err := remote.ReadFromUDP(buf)
		if err != nil {
			log.Printf("read remote %s failed: %s", remote.LocalAddr().String(), err.Error())
			return
		}

		rlen := len(raddr.String())
		data := make([]byte, rlen+1+n)
		copy(data, []byte(raddr.String()))
		copy(data[rlen:], []byte(" "))
		copy(data[rlen+1:], buf[:n])
		handle.WriteToUDP(data, src)
	}
}

func handlePacket(handle *net.UDPConn, src *net.UDPAddr, b []byte) {
	n := bytes.IndexByte(b, byte(' '))
	if n == -1 {
		log.Printf("invalid data: %s", string(b))
		return
	}

	dst := string(b[:n])
	dstAddr, err := net.ResolveUDPAddr("udp", dst)
	if err != nil {
		log.Printf("invalid dstip: %s", dst)
		return
	}

	remote, exist, err := natlist.Get(src.String())
	if err != nil {
		log.Printf("nat failed: %s", err.Error())
		return
	}
	remote.SetDeadline(time.Now().Add(udpTimeout))
	if !exist {
		go func() {
			defer natlist.Delete(src.String())
			pipe(handle, src, remote)
		}()
	}
	_, err = remote.WriteToUDP(b, dstAddr)
	if err != nil {
		log.Printf("write to %s failed: %s", dst, err.Error())
	} else {
		log.Printf("write to %s succeed", dst)
	}
}

// protocol:
// ip:port payload
func main() {
	listen := flag.String("listen", "127.0.0.1:8828", "udp listen address")
	flag.Parse()

	laddr, err := net.ResolveUDPAddr("udp", *listen)
	if err != nil {
		log.Fatalf("parse listen address failed: %s", err.Error())
	}

	lu, err := net.ListenUDP("udp", laddr)
	if err != nil {
		log.Fatalf("listen failed: %s", err.Error())
	}
	log.Printf("listen on: %s", *listen)

	for {
		buf := make([]byte, 4096)
		n, src, err := lu.ReadFromUDP(buf)
		if err != nil {
			log.Fatalf("read failed: %s", err.Error())
			break
		}
		log.Printf("receive packet from %s, len %d", src.String(), n)
		go handlePacket(lu, src, buf[:n])
	}
}

Usage:
term1: start udprelay:

go run udprelay.go

term2: start a udp service with nc:

nc -u -l 0 9299

term3: start nc as a udprelay client:

nc -u 127.0.0.1 8828

then send message through the client

127.0.0.1:9299 hello

you will see the message in term2, then you can echo by typing something in term2.