Add c-data-channels example

Resolves pion#29

Author: lherman-cs

README.md

@@ -58,6 +58,7 @@ Check out the **[contributing wiki](https://github.com/pion/webrtc/wiki/Contribu
 * [CloudWebRTC|湖北捷智云技术有限公司](https://github.com/cloudwebrtc) - *Flutter example for SFU-WS*
 * [Atsushi Watanabe](https://github.com/at-wat) - *WebM muxer example*
 * [Jadon Bennett](https://github.com/jsjb)
+* [Lukas Herman](https://github.com/lherman-cs) - *C Data Channels example*
 
 ### License
 MIT License - see [LICENSE](LICENSE) for full text

c-data-channels/Makefile

@@ -0,0 +1,8 @@
+c-data-channels: webrtc.so data-channels.c
+	gcc -o $@ data-channels.c ./webrtc.so
+
+webrtc.so: webrtc.go bridge.go 
+	go build -o $@ -buildmode=c-shared $^
+
+clean:
+	rm webrtc.so webrtc.h c-data-channels

c-data-channels/README.md

@@ -0,0 +1,56 @@
+# c-data-channels
+c-data-channels is a Pion WebRTC application that shows how you can send/recv DataChannel messages from a web browser that's 
+mostly identical to the pure Go implementation, https://github.com/pion/webrtc/tree/master/examples/data-channels.
+The main difference is that the OnDataChannel is fully implemented in C.
+
+## Instructions
+### Clone c-data-channels
+```
+git clone https://github.com/pion/example-webrtc-applications.git
+```
+
+### Go into the c-data-channels example directory
+```
+cd example-webrtc-applications/c-data-channels
+```
+
+### Build it
+```
+make
+```
+
+### Open data-channels example page
+[jsfiddle.net](https://jsfiddle.net/9tsx15mg/90/)
+
+### Run data-channels, with your browsers SessionDescription as stdin
+In the jsfiddle the top textarea is your browser's session description, copy that and:
+#### Linux/macOS
+Run `echo $BROWSER_SDP | c-data-channels`
+#### Windows
+1. Paste the SessionDescription into a file.
+1. Run `c-data-channels < my_file`
+
+### Input data-channels's SessionDescription into your browser
+Copy the text that `c-data-channels` just emitted and copy into second text area
+
+### Hit 'Start Session' in jsfiddle
+Under Start Session you should see 'Checking' as it starts connecting. If everything worked you should see `New DataChannel foo 1`
+
+Now you can put whatever you want in the `Message` textarea, and when you hit `Send Message` it should appear in your browser!
+
+You can also type in your terminal, and when you hit enter it will appear in your web browser.
+
+Congrats, you have used Pion WebRTC! Now start building something cool
+
+## Organization
+
+### bridge.go
+This file contains all of the bridging between Go and C. This is the only file that contains cgo stuff.
+
+### webrtc.go
+This file is pure Go. It is mostly identical to the original data-channel example.
+
+### Reference
+* https://github.com/golang/go/issues/20639
+* https://github.com/golang/go/issues/25832
+* https://github.com/pion/webrtc/tree/master/examples/data-channels/jsfiddle - jsfiddle source codes

c-data-channels/bridge.go

@@ -0,0 +1,97 @@
+package main
+
+/*
+#include <stddef.h>
+#include <stdint.h>
+typedef struct GoDataChannelMessage
+{
+    // bool in cgo is really weird, so it's simpler to just use classic int as bool
+    int is_string;
+    void *data;
+    size_t data_len;
+} GoDataChannelMessage;
+
+typedef uint16_t GoDataChannel;
+typedef void (*GoOnDataChannelFunc)(GoDataChannel);
+typedef void (*GoOnOpenFunc)(GoDataChannel);
+typedef void (*GoOnMessageFunc)(GoDataChannel, GoDataChannelMessage);
+
+// Calling C function pointers is currently not supported, however you can
+// declare Go variables which hold C function pointers and pass them back
+// and forth between Go and C. C code may call function pointers received from Go.
+// Reference: https://golang.org/cmd/cgo/#hdr-Go_references_to_C
+inline void bridge_on_data_channel(GoOnDataChannelFunc cb, GoDataChannel d)
+{
+    cb(d);
+}
+
+inline void bridge_on_open(GoOnOpenFunc cb, GoDataChannel d)
+{
+	cb(d);
+}
+
+inline void bridge_on_message(GoOnMessageFunc cb, GoDataChannel d, GoDataChannelMessage msg)
+{
+	cb(d, msg);
+}
+*/
+import "C"
+
+import (
+	"github.com/pion/webrtc/v2"
+)
+
+var store = map[C.GoDataChannel]*webrtc.DataChannel{}
+
+//export GoRun
+func GoRun(f C.GoOnDataChannelFunc) {
+	Run(func(d *webrtc.DataChannel) {
+		// Since cgo doesn't allow storing Go pointers in C, we need to store some data in C
+		// that can tell Go how to get webrtc.DataChannel later. So, here we simply use data channel's
+		// id, which is just a simple 16 unsigned int that we can pass easily from/to C.
+		id := C.GoDataChannel(*d.ID())
+		store[id] = d
+		C.bridge_on_data_channel(f, id)
+	})
+}
+
+//export GoOnOpen
+func GoOnOpen(d C.GoDataChannel, f C.GoOnOpenFunc) {
+	// get the actual DataChannel using a unique id
+	dc := store[d]
+	dc.OnOpen(func() {
+		C.bridge_on_open(f, d)
+	})
+}
+
+//export GoOnMessage
+func GoOnMessage(d C.GoDataChannel, f C.GoOnMessageFunc) {
+	dc := store[d]
+	dc.OnMessage(func(msg webrtc.DataChannelMessage) {
+		var isString int
+		// Since C interprets non-zero to be true, we can simply set isString to be 1
+		// or any non-zero value to make C to think that isString is true
+		if msg.IsString {
+			isString = 1
+		}
+
+		cMsg := C.GoDataChannelMessage{
+			is_string: C.int(isString),
+			data:      C.CBytes(msg.Data),
+			data_len:  C.ulong(len(msg.Data)),
+		}
+		C.bridge_on_message(f, d, cMsg)
+	})
+}
+
+//export GoSendText
+func GoSendText(d C.GoDataChannel, t *C.char) {
+	dc := store[d]
+	dc.SendText(C.GoString(t))
+}
+
+//export GoLabel
+func GoLabel(d C.GoDataChannel) *C.char {
+	dc := store[d]
+	return C.CString(dc.Label())
+}

c-data-channels/data-channels.c

@@ -0,0 +1,69 @@
+#include "webrtc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+
+void on_data_channel(GoDataChannel d);
+void on_open(GoDataChannel d);
+void on_message(GoDataChannel d, struct GoDataChannelMessage msg);
+char *rand_seq(int n);
+
+int main()
+{
+    // Register data channel creation handling
+    GoRun(on_data_channel);
+}
+
+void on_data_channel(GoDataChannel d)
+{
+    // Register channel opening handling
+    GoOnOpen(d, on_open);
+    // Register text message handling
+    GoOnMessage(d, on_message);
+}
+
+void on_open(GoDataChannel d)
+{
+    char *label = GoLabel(d);
+    // d = DataChannel.ID() since we pass this from Go
+    printf("Data channel '%s'-'%d' open. Random messages will now be sent to any connected DataChannels every 5 seconds\n", label, d);
+    free(label);
+
+    while (1)
+    {
+        sleep(5);
+        char *message = rand_seq(15);
+        printf("Sending '%s'\n", message);
+
+        // Send the message as text
+        GoSendText(d, message);
+        free(message);
+    }
+}
+
+void on_message(GoDataChannel d, struct GoDataChannelMessage msg)
+{
+    char *label = GoLabel(d);
+    printf("Message from DataChannel '%s': '%s'\n", label, (char *)(msg.data));
+    // since we use C.CBytes and C.CString to convert label and msg.data,
+    // the converted data are allocated using malloc. So, we need to free them.
+    // Reference: https://golang.org/cmd/cgo/#hdr-Go_references_to_C
+    free(label);
+    free(msg.data);
+}
+
+char *rand_seq(int n)
+{
+    srand(time(0));
+    char letters[52] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    int n_letters = sizeof(letters) / sizeof(char);
+    char *b = malloc(sizeof(char) * (n + 1));
+    for (int i = 0; i < n; i++)
+    {
+        b[i] = letters[rand() % n_letters];
+    }
+    b[n] = '\0';
+    return b;
+}

c-data-channels/webrtc.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/pion/example-webrtc-applications/internal/signal"
+	"github.com/pion/webrtc/v2"
+)
+
+// Run contains pure Go codes to do the heavy lifting. In fact, the codes
+// are almost identical to the data-channel example that is written in pure Go,
+// https://github.com/pion/webrtc/tree/master/examples/data-channels.
+// The only difference is that Run lets you to define the OnDataChannel callback in C.
+func Run(f func(*webrtc.DataChannel)) {
+	// Everything below is the Pion WebRTC API! Thanks for using it ❤️.
+
+	// Prepare the configuration
+	config := webrtc.Configuration{
+		ICEServers: []webrtc.ICEServer{
+			{
+				URLs: []string{"stun:stun.l.google.com:19302"},
+			},
+		},
+	}
+
+	// Create a new RTCPeerConnection
+	peerConnection, err := webrtc.NewPeerConnection(config)
+	if err != nil {
+		panic(err)
+	}
+
+	// Set the handler for ICE connection state
+	// This will notify you when the peer has connected/disconnected
+	peerConnection.OnICEConnectionStateChange(func(connectionState webrtc.ICEConnectionState) {
+		fmt.Printf("ICE Connection State has changed: %s\n", connectionState.String())
+	})
+
+	// Register data channel creation handling
+	peerConnection.OnDataChannel(f)
+
+	// Wait for the offer to be pasted
+	offer := webrtc.SessionDescription{}
+	signal.Decode(signal.MustReadStdin(), &offer)
+
+	// Set the remote SessionDescription
+	err = peerConnection.SetRemoteDescription(offer)
+	if err != nil {
+		panic(err)
+	}
+
+	// Create an answer
+	answer, err := peerConnection.CreateAnswer(nil)
+	if err != nil {
+		panic(err)
+	}
+
+	// Sets the LocalDescription, and starts our UDP listeners
+	err = peerConnection.SetLocalDescription(answer)
+	if err != nil {
+		panic(err)
+	}
+
+	// Output the answer in base64 so we can paste it in browser
+	fmt.Println(signal.Encode(answer))
+
+	// Block forever
+	select {}
+}
+
+func main() {}