Cannot get UDP hole punching right. Error: recvfrom: connection refused - sockets

Question

I am trying to connect two peers behind same NAT using UDP hole punching but whenever 1 client send UDP packet to other client, it receives error:
read udp4 192.168.0.xx:xx->192.168.0.xx:xx: recvfrom: connection refused
I followed implementation from here.
Some background about my code:
server.go
init UDP server
start listening for packets on given IP:PORT (user input)
a. receive packet of type new_connection for new client (does not exist already), store client_name, IP:PORT mapping in a variable and send connection_success in response.
b. receive packet of type connection_request from client A requesting from B's details, send mapping_response packet to client A with B's details and send client B peer_request packet with A's details.
code for server.go:
package main
import (
"net"
"fmt"
"strings"
"os"
)
var mapping map[string]*net.UDPAddr
func initServer(addr string) (*net.UDPConn, error) {
s, err := net.ResolveUDPAddr("udp4", addr)
if err != nil {
fmt.Println(err.Error())
return nil, err
}
c, err := net.ListenUDP("udp4", s)
return c, nil
}
func main() {
port := ":" + os.Args[1]
mapping = make(map[string]*net.UDPAddr)
c, err := initServer(port)
defer c.Close()
if err != nil {
return
}
listen(c)
}
func listen(c *net.UDPConn) {
buffer := make([]byte, 1024)
for {
n, addr, err := c.ReadFromUDP(buffer)
if err != nil {
fmt.Println(err.Error())
} else {
s := strings.Split(string(buffer[0:n]), " ")
packetType, packetData := s[0], s[1]
go handle(c, packetType, packetData, addr)
}
}
}
func addMapping(c *net.UDPConn, data string, addr *net.UDPAddr) {
if _, ok := mapping[data]; !ok {
mapping[data] = addr
fmt.Println(mapping)
data := generateData("connection_success", "hello")
sendResponse(c, data, addr)
}
}
func makeConnection(c *net.UDPConn, name string, addr1 *net.UDPAddr) {
addr2 := getAddress(name)
var data string
data = generateData("mapping_response", addr2.String())
sendResponse(c, data, addr1)
data = generateData("peer_request", addr1.String())
sendResponse(c, data, addr2)
}
func handle(c *net.UDPConn, packetType string, packetData string, addr *net.UDPAddr) {
switch packetType {
case "new_connection":
addMapping(c, packetData, addr)
case "connection_request":
makeConnection(c, packetData, addr)
default:
break
}
}
func getAddress(name string) *net.UDPAddr {
return mapping[name]
}
func generateData(packetType string, packetData string) string {
return fmt.Sprintf("%s %s", packetType, packetData)
}
func sendResponse(c *net.UDPConn, data string, addr *net.UDPAddr) {
fmt.Println(data, addr)
_, err := c.WriteToUDP([]byte(data), addr)
if err != nil {
fmt.Println(err.Error())
}
}
client.go
init UDP client for server
get client_name as input (user input)
send packet of type new_connection to server every 10s.
a. receive packet of type connection_success, ask user whom to connect with (client B) and send connection_request packet to server asking B's details.
b. receive packet of type mapping_response, try to connect to client B by using sending establish_connection packet to client B every 3s.
c. receive packet of type peer_request, try same thing as 3b from client B side.
code for client.go:
package main
import (
"fmt"
"bufio"
"os"
"net"
"time"
"strings"
)
func initClient(addr string) (*net.UDPConn, error) {
s, err := net.ResolveUDPAddr("udp4", addr)
c, err := net.DialUDP("udp4", nil, s)
if err != nil {
fmt.Println(err.Error())
return nil, err
}
return c, nil
}
func main() {
serverAddress := os.Args[1]
c, err := initClient(serverAddress)
if err != nil {
return
}
defer c.Close()
name := getInput()
go addMappingToServer(c, name)
listen(c)
}
func addMappingToServer(c *net.UDPConn, name string) {
for {
data := generateData("new_connection", name)
sendPacket(c, data)
time.Sleep(10*time.Second)
}
}
func listen(c *net.UDPConn) {
buffer := make([]byte, 1024)
for {
n, addr, err := c.ReadFromUDP(buffer)
if err != nil {
fmt.Println(err.Error())
} else {
s := strings.Split(string(buffer[0:n]), " ")
packetType, packetData := s[0], s[1]
go handle(c, packetType, packetData, addr)
}
}
}
func handle(c *net.UDPConn, packetType string, packetData string, addr *net.UDPAddr) {
fmt.Println(packetType, packetData)
switch packetType {
case "connection_success":
getPeerMapping(c)
case "peer_request":
establishConnectionToPeer(packetData)
case "mapping_response":
establishConnectionToPeer(packetData)
default:
break
}
}
func generateData(packetType string, packetData string) string {
return fmt.Sprintf("%s %s", packetType, packetData)
}
func sendPacket(c *net.UDPConn, data string) {
_, err := c.Write([]byte(data))
if err != nil {
fmt.Println(err.Error())
}
}
func sendPacketToAddr(c *net.UDPConn, data string, addr *net.UDPAddr) {
_, err := c.WriteToUDP([]byte(data), addr)
if err != nil {
fmt.Println(err.Error())
}
}
func getInput() string {
reader := bufio.NewReader(os.Stdin)
fmt.Print(">> ")
text, _ := reader.ReadString('\n')
return text[0:len(text)-1]
}
func getPeerMapping(c *net.UDPConn) {
peer := getInput()
data := generateData("connection_request", peer)
sendPacket(c, data)
}
func establishConnectionToPeer(peerAddr string) {
c, err := initClient(peerAddr)
if err != nil {
fmt.Println(err.Error())
return
}
defer c.Close()
buffer := make([]byte, 1024)
for {
data := generateData("establish_connection", "hello")
sendPacket(c, data)
n, addr, err := c.ReadFromUDP(buffer)
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println("packet recieved from peer data : %s, addr : %#v", string(buffer[0:n]), addr)
break
}
time.Sleep(3*time.Second)
}
}
The problem that I am facing is in line
n, addr, err := c.ReadFromUDP(buffer)
inside establishConnectionToPeer function and I am getting error I mentioned above (connection refused).
Scenario
Client A and server are on 1 host and client B on another. Both hosts are behind same NAT.
Sample output:
for server:
map[abc:192.168.0.78:45999 xyz:192.168.0.10:44207]
meaning client abc's IP:PORT is 192.168.0.78:45999 and for xyz, it is 192.168.0.10:44207
for client abc:
read udp4 192.168.0.78:40934->192.168.0.10:44207: recvfrom: connection refused
for client xyz:
read udp4 192.168.0.10:49708->192.168.0.78:45999: recvfrom: connection refused
Problem is clear: both clients opened another port (different from what they opened to communicate from server)
What is wrong with the client code above, and what can I do to resolve it? It would be great if someone can provide (or modify above) code piece to make it start working.
I assume it's not the case that my router does not support UDP hole punching because I can use skype using it (and I read from here that skype uses hole punching).