Connection issues in a simple data channel example

[rprata]

Hello everyone,

I started studying the Pion project to explore the use of data channels with Go. I created a very simple example consisting of two programs (client.go, receiver.go and sender.go) to establish a connection and exchange messages between them. The solution works when on the same network, but fails when running on different networks. Looking at the SDPs, I see that there are reflexive candidates and the public IP of both is valid. What could be the problem? Is there a way to better debug the error? Here are the files I use:

client.go:

package client

import (
	signal "ember/internal/p2p/utils"
	"fmt"
	"log"

	"github.com/pion/webrtc/v4"
)

type TurnServer struct {
	URL            string
	Username       string
	Credential     string
	CredentialType webrtc.ICECredentialType
}
type Configuration struct {
	StunServers []string
	TurnServer  *TurnServer
}

type Client struct {
	configuration  *Configuration
	peerConnection *webrtc.PeerConnection
}

func NewClient(configuration Configuration) *Client {
	return &Client{
		configuration: &Configuration{},
	}
}

func DefaultClient() *Client {
	return NewClient(Configuration{
		StunServers: []string{"stun:stun.l.google.com:19302"},
		TurnServer:  nil,
	})
}

func (c *Client) Prepare() error {
	config := webrtc.Configuration{
		ICEServers: []webrtc.ICEServer{
			{
				URLs: []string{"stun:stun.l.google.com:19302"},
			},
		},
	}

	var err error
	c.peerConnection, err = webrtc.NewPeerConnection(config)
	if err != nil {
		return err
	}

	c.peerConnection.OnICECandidate(func(i *webrtc.ICECandidate) {
		if i != nil {
			fmt.Println("Candidato ICE descoberto:", i.ToJSON().Candidate)
		}
	})

	c.peerConnection.OnConnectionStateChange(func(s webrtc.PeerConnectionState) {
		log.Printf("Peer Connection State has changed: %s\n", s.String())

		if s == webrtc.PeerConnectionStateFailed {
			log.Println("Peer Connection has gone to failed exiting")
		}

		if s == webrtc.PeerConnectionStateClosed {
			log.Println("Peer Connection has gone to closed exiting")
		}
	})

	return nil
}

func (c *Client) Close() {
	if cErr := c.peerConnection.Close(); cErr != nil {
		log.Println("cannot close peerConnection:", cErr)
	}
}

func (c *Client) RegisterOnDataChannel(senderCb func(d *webrtc.DataChannel), readerCb func([]uint8)) {
	c.peerConnection.OnDataChannel(func(d *webrtc.DataChannel) {
		log.Printf("DataChannel %s - %d opened\n", d.Label(), d.ID())
		d.OnOpen(func() {
			log.Printf("DataChannel %s - %d opened\n", d.Label(), d.ID())
			d.SendText("Hello")
			senderCb(d)
		})

		d.OnMessage(func(msg webrtc.DataChannelMessage) {
			log.Printf("DataChannel %s received message: %s\n", d.Label(), string(msg.Data))
			readerCb(msg.Data)
		})
	})
}

func (c *Client) CreateDataChannel(channelName string, senderCb func(d *webrtc.DataChannel), readerCb func([]uint8)) {
	dataChannel, err := c.peerConnection.CreateDataChannel(channelName, nil)
	if err != nil {
		log.Fatal(err)
	}

	dataChannel.OnOpen(func() {
		log.Printf("DataChannel %s - %d opened\n", dataChannel.Label(), dataChannel.ID())
		dataChannel.SendText("Hello")
		senderCb(dataChannel)
	})

	dataChannel.OnMessage(func(msg webrtc.DataChannelMessage) {
		log.Printf("DataChannel %s received message: %s\n", channelName, string(msg.Data))
	})
}

func (c *Client) CreateOffer() (string, error) {

	offer, err := c.peerConnection.CreateOffer(nil)
	if err != nil {
		return "", err
	}

	err = c.peerConnection.SetLocalDescription(offer)
	if err != nil {
		return "", err
	}

	return signal.Encode(offer), nil
}

func (c *Client) SetRemoteDescription(sdp string) error {
	decoded := webrtc.SessionDescription{}
	signal.Decode(sdp, &decoded)

	err := c.peerConnection.SetRemoteDescription(decoded)
	if err != nil {
		return err
	}

	return nil
}

func (c *Client) CreateAnswer(sdp string) (string, error) {
	decoded := webrtc.SessionDescription{
		Type: webrtc.SDPTypeAnswer,
	}
	signal.Decode(sdp, &decoded)

	err := c.peerConnection.SetRemoteDescription(decoded)
	if err != nil {
		return "", err
	}

	answer, err := c.peerConnection.CreateAnswer(nil)
	if err != nil {
		return "", err
	}

	gatherComplete := webrtc.GatheringCompletePromise(c.peerConnection)

	err = c.peerConnection.SetLocalDescription(answer)
	if err != nil {
		return "", err
	}

	<-gatherComplete
	return signal.Encode(*c.peerConnection.LocalDescription()), nil
}

receiver.go

package main

import (
	"ember/internal/p2p/client"
	"fmt"
	"os"
	"time"

	"github.com/pion/webrtc/v4"
)

func senderCb(d *webrtc.DataChannel) {
	// fmt.Println("Sending...")
}

func readerCb(data []uint8) {
	fmt.Printf("Received: %s\n", string(data))
}

func ReadFileContinuously(filePath string) string {
	for {
		file, err := os.Open(filePath)
		if err != nil {
			fmt.Printf("Erro ao abrir o arquivo: %v\n", err)
			time.Sleep(time.Second) // Espera antes de tentar novamente
			continue
		}
		defer file.Close()

		stat, err := file.Stat()
		if err != nil {
			fmt.Printf("Erro ao obter informações do arquivo: %v\n", err)
			time.Sleep(time.Second) // Espera antes de tentar novamente
			continue
		}

		if stat.Size() > 0 {
			content := make([]byte, stat.Size())
			_, err := file.Read(content)
			if err != nil {
				fmt.Printf("Erro ao ler o conteúdo do arquivo: %v\n", err)
				time.Sleep(time.Second) // Espera antes de tentar novamente
				continue
			}
			return string(content)
		}

		time.Sleep(time.Second) // Espera antes de tentar novamente
	}
}

func main() {
	fmt.Println("Start...")
	c := client.DefaultClient()
	if err := c.Prepare(); err != nil {
		panic(err)
	}
	fmt.Println("Prepared...")

	c.CreateDataChannel("ember-channel", senderCb, readerCb)
	fmt.Println("DataChannel Created...")

	sdp, err := c.CreateOffer()
	if err != nil {
		panic(err)
	}
	fmt.Println("Offer created...")
	fmt.Println(sdp)

	stringFromfile := ReadFileContinuously("cmd/ember/sdp-offer.txt")
	fmt.Println(stringFromfile)
	err = c.SetRemoteDescription(stringFromfile)
	if err != nil {
		panic(err)
	}

	select {}
}

sender.go

package main

import (
	"ember/internal/p2p/client"
	signal "ember/internal/p2p/utils"
	"fmt"
	"time"

	"github.com/pion/webrtc/v4"
)

func senderCb(dataChannel *webrtc.DataChannel) {
	for {
		fmt.Println("Sending...")
		if err := dataChannel.Send([]byte("hello!")); err != nil {
			panic(err)
		}
		time.Sleep(5 * time.Second)
	}
}

func readerCb(data []uint8) {
	fmt.Printf("Received: %s\n", string(data))
}

func main() {
	fmt.Println("Start...")
	c := client.DefaultClient()
	if err := c.Prepare(); err != nil {
		panic(err)
	}
	fmt.Println("Prepared...")

	c.RegisterOnDataChannel(senderCb, readerCb)
	fmt.Println("Registered...")

	inSdp := signal.MustReadStdin()
	sdp, err := c.CreateAnswer(inSdp)
	if err != nil {
		panic(err)
	}
	fmt.Println("Answer created...")
	fmt.Println(sdp)

	// fmt.Println("Done.")
	select {}
}