Exchange messages using Windows environment

[netwer]

Hi, we are trying to sending message using windows environment.

We have 1 server instance run on the Windows from NAT network and other one client instance run on the Windows from NAT network on other PC.

As the result we cant exhange messages and we cant see any errors.

Can you help as run this solution using Windows enviroment, because is it important for us?

If you need we can gve you as information you want.

Thanks.

PS we are using this example: https://github.com/pions/webrtc/tree/master/examples/pion-to-pion

[backkem]

Hi @netwer. Glad to have you use the library!
Note that WebRTC should be able to traverse NATs. However, the pion-to-pion example uses a direct HTTP connection to exchange the SDP information. This HTTP connection is not able to traverse NAT. For use-cases where both peers are behind NAT you would need to exchange the SDP over a rendezvous server, that is a server that both peers can make a direct connection to individually. Do you think this could explain the problem?
We should probably do a better job of explaining this in the example and maybe add a rendezvous example as well.

[backkem]

Actually, I seem to be able to reproduce this. I'll need to find more time for testing, please stand by.

[Sean-Der]

Hey @netwer can you try master please?

@backkem fixed a bug where we could get IPv6 srflx candidates back from the STUN server (and then we would fail to parse them) so you would only end up with host candidates.

[netwer]

@backkem @Sean-Der Hey!
We are tried changes from master and no successful result.
We are use the following pion scripts for testing:

1 pion script:

package main

import (
	"bufio"
	"encoding/base64"
	"fmt"
	"io"
	"math/rand"
	"os"
	"time"

	"github.com/pions/webrtc"
	"github.com/pions/webrtc/pkg/datachannel"
	"github.com/pions/webrtc/pkg/ice"
)

func main() {
	/* Everything below is the pion-WebRTC API, thanks for using it! */

	// Prepare the configuration
	config := webrtc.RTCConfiguration{
		IceServers: []webrtc.RTCIceServer{
			{
				URLs: []string{"stun:stun.l.google.com:19302"},
			},
		},
	}

	// Create a new RTCPeerConnection
	peerConnection, err := webrtc.New(config)
	check(err)

	// Set the handler for ICE connection state
	// This will notify you when the peer has connected/disconnected
	peerConnection.OnICEConnectionStateChange = func(connectionState ice.ConnectionState) {
		fmt.Printf("ICE Connection State has changed: %s\n", connectionState.String())
	}

	// Register data channel creation handling
	peerConnection.OnDataChannel = func(d *webrtc.RTCDataChannel) {
		fmt.Printf("New DataChannel %s %d\n", d.Label, d.ID)

		d.Lock()
		defer d.Unlock()

		// Register channel opening handling
		d.OnOpen = func() {
			fmt.Printf("Data channel '%s'-'%d' open. Random messages will now be sent to any connected DataChannels every 5 seconds\n", d.Label, d.ID)

			for range time.NewTicker(5 * time.Second).C {
				message := randSeq(15)
				fmt.Printf("Sending %s \n", message)

				err := d.Send(datachannel.PayloadString{Data: []byte(message)})
				check(err)
			}
		}

		// Register message handling
		d.Onmessage = func(payload datachannel.Payload) {
			switch p := payload.(type) {
			case *datachannel.PayloadString:
				fmt.Printf("Message '%s' from DataChannel '%s' payload '%s'\n", p.PayloadType().String(), d.Label, string(p.Data))
			case *datachannel.PayloadBinary:
				fmt.Printf("Message '%s' from DataChannel '%s' payload '% 02x'\n", p.PayloadType().String(), d.Label, p.Data)
			default:
				fmt.Printf("Message '%s' from DataChannel '%s' no payload \n", p.PayloadType().String(), d.Label)
			}
		}
	}


	// Wait for the offer to be pasted
	sd := mustReadStdin()

	// Set the remote SessionDescription
	offer := webrtc.RTCSessionDescription{
		Type: webrtc.RTCSdpTypeOffer,
		Sdp:  string(sd),
	}

	err = peerConnection.SetRemoteDescription(offer)
	check(err)

	// Sets the LocalDescription, and starts our UDP listeners
	answer, err := peerConnection.CreateAnswer(nil)
	check(err)

	// Get the LocalDescription and take it to base64 so we can paste in browser
	fmt.Println(base64.StdEncoding.EncodeToString([]byte(answer.Sdp)))

	// Block forever
	select {}
}

func randSeq(n int) string {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
	b := make([]rune, n)
	for i := range b {
		b[i] = letters[r.Intn(len(letters))]
	}
	return string(b)
}

// check is used to panic in an error occurs.
func check(err error) {
	if err != nil {
		panic(err)
	}
}

// mustReadStdin blocks untill input is received from stdin
func mustReadStdin() string {
	reader := bufio.NewReader(os.Stdin)
	rawSd, err := reader.ReadString('\n')
	if err != io.EOF {
		check(err)
	}

	fmt.Println("")

	sd, err := base64.StdEncoding.DecodeString(rawSd)
	check(err)

	return string(sd)
}

2 pion script:

package main

import (
	"bufio"
	"encoding/base64"
	"fmt"
	"io"
	"math/rand"
	"os"
	"time"

	"github.com/pions/webrtc"
	"github.com/pions/webrtc/pkg/datachannel"
	"github.com/pions/webrtc/pkg/ice"
)

func main() {
	// Prepare the configuration
	config := webrtc.RTCConfiguration{
		IceServers: []webrtc.RTCIceServer{
			{
				URLs: []string{"stun:stun.l.google.com:19302"},
			},
		},
	}

	// Create a new RTCPeerConnection
	peerConnection, err := webrtc.New(config)
	check(err)

	// Create a datachannel with label 'data'
	dataChannel, err := peerConnection.CreateDataChannel("data", nil)
	check(err)

	// Set the handler for ICE connection state
	// This will notify you when the peer has connected/disconnected
	peerConnection.OnICEConnectionStateChange = func(connectionState ice.ConnectionState) {
		fmt.Printf("ICE Connection State has changed: %s\n", connectionState.String())
	}

	dataChannel.Lock()

	// Register channel opening handling
	dataChannel.OnOpen = func() {
		fmt.Printf("Data channel '%s'-'%d' open. Random messages will now be sent to any connected DataChannels every 5 seconds\n", dataChannel.Label, dataChannel.ID)

		for range time.NewTicker(5 * time.Second).C {
			message := randSeq(15)
			fmt.Printf("Sending %s \n", message)

			err := dataChannel.Send(datachannel.PayloadString{Data: []byte(message)})
			check(err)
		}
	}

	// Register the Onmessage to handle incoming messages
	dataChannel.Onmessage = func(payload datachannel.Payload) {
		switch p := payload.(type) {
		case *datachannel.PayloadString:
			fmt.Printf("Message '%s' from DataChannel '%s' payload '%s'\n", p.PayloadType().String(), dataChannel.Label, string(p.Data))
		case *datachannel.PayloadBinary:
			fmt.Printf("Message '%s' from DataChannel '%s' payload '% 02x'\n", p.PayloadType().String(), dataChannel.Label, p.Data)
		default:
			fmt.Printf("Message '%s' from DataChannel '%s' no payload \n", p.PayloadType().String(), dataChannel.Label)
		}
	}

	dataChannel.Unlock()

	// Create an offer to send to the browser
	offer, err := peerConnection.CreateOffer(nil)
	check(err)

	// Output the offer in base64 so we can paste it in browser
	fmt.Println(base64.StdEncoding.EncodeToString([]byte(offer.Sdp)))

	// Exchange the offer for the answer
	//answer := mustSignalViaHTTP(offer, *addr)

	// Wait for the answer to be pasted
	sd := mustReadStdin()

	// Set the remote SessionDescription
	answer := webrtc.RTCSessionDescription{
		Type: webrtc.RTCSdpTypeAnswer,
		Sdp:  sd,
	}

	// Apply the answer as the remote description
	err = peerConnection.SetRemoteDescription(answer)
	check(err)

	// Block forever
	select {}
}

func randSeq(n int) string {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
	b := make([]rune, n)
	for i := range b {
		b[i] = letters[r.Intn(len(letters))]
	}
	return string(b)
}

// check is used to panic in an error occurs.
func check(err error) {
	if err != nil {
		panic(err)
	}
}

// mustReadStdin blocks untill input is received from stdin
func mustReadStdin() string {
	reader := bufio.NewReader(os.Stdin)
	rawSd, err := reader.ReadString('\n')
	if err != io.EOF {
		check(err)
	}

	fmt.Println("")

	sd, err := base64.StdEncoding.DecodeString(rawSd)
	check(err)

	return string(sd)
}

[backkem]

Yes, I seems my fix isn't complete yet. I should have more time tomorrow evening and in the weekend for further debugging.

[netwer]

Ou, thanks! We will be waiting you fix.