Removed the use of 'curl'

README.md

@@ -23,15 +23,19 @@ As of today, it works well with small files. It doesn't work with huge files, du
 ### Sender
 
 ```bash
+# Terminal 1
 gfile send --file filename
+
+# Terminal 2
+echo "$SDP" | gfile sdp
 ```
 
 -   Run the command
 -   A base64 encoded SDP will appear, send it to the remote client
--   Follow the instructions to curl the client's SDP to your process
+-   Follow the instructions to send the client's SDP to your process
 -   The file transfer should start
 
-> Due to terms restrictions (ability to treat lines with +1024 characters), the SDP must be sent through `curl`
+> Due to terms restrictions (ability to treat lines with +1024 characters), the SDP must be sent through the `gfile sdp` command
 
 ### Receiver
 

cmd/install.go

@@ -4,6 +4,7 @@ import (
 	"sort"
 
 	"github.com/Antonito/gfile/cmd/receive"
+	"github.com/Antonito/gfile/cmd/sdp"
 	"github.com/Antonito/gfile/cmd/send"
 	"gopkg.in/urfave/cli.v1"
 )
@@ -13,6 +14,7 @@ func Install(app *cli.App) {
 	app.Commands = []cli.Command{
 		send.New(),
 		receive.New(),
+		sdp.New(),
 	}
 	sort.Sort(cli.CommandsByName(app.Commands))
 }

cmd/sdp/cmd.go

@@ -0,0 +1,51 @@
+package sdp
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/Antonito/gfile/pkg/utils"
+	"github.com/pions/webrtc"
+	"gopkg.in/urfave/cli.v1"
+)
+
+func handler(c *cli.Context) error {
+	var encoded string
+	for {
+		data, err := utils.MustReadStdin()
+		if err == nil {
+			// We decode it, but never use it,
+			// just to make sure the data is correct
+			offer := webrtc.SessionDescription{}
+			if err := utils.Decode(data, &offer); err == nil {
+				encoded = data
+				break
+			}
+		}
+		fmt.Println("Invalid SDP, try again...")
+	}
+
+	body := strings.NewReader(encoded)
+	req, err := http.NewRequest("POST", "http://localhost:8080/sdp", body)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return nil
+}
+
+// New creates the command
+func New() cli.Command {
+	return cli.Command{
+		Name:   "sdp",
+		Usage:  "Sends a SDP to the already running instance of the `send` command",
+		Action: handler,
+	}
+}

cmd/send/session/init.go

@@ -24,7 +24,7 @@ func (s *Session) Connect() error {
 
 	// Wait for the answer to be pasted
 	fmt.Println(`Please, provide the SDP via:
-curl localhost:8080/sdp --data "$SDP"`)
+echo "$SDP" | gfile sdp`)
 	answer := webrtc.SessionDescription{}
 	for {
 		if err := utils.Decode(<-sdpChan, &answer); err == nil {
@@ -84,12 +84,9 @@ func (s *Session) createOffer() error {
 }
 
 func (s *Session) createDataChannel() error {
-	ordered := true
-	maxPacketLifeTime := uint16(5000)
-	dataChannel, err := s.peerConnection.CreateDataChannel("data", &webrtc.DataChannelInit{
-		Ordered:           &ordered,
-		MaxPacketLifeTime: &maxPacketLifeTime,
-	})
+	//ordered := true
+	//maxPacketLifeTime := uint16(0xFFFF)
+	dataChannel, err := s.peerConnection.CreateDataChannel("data", nil)
 	if err != nil {
 		return err
 	}

cmd/send/session/state.go

@@ -13,7 +13,6 @@ func (s *Session) setStateManager() {
 	// This will notify you when the peer has connected/disconnected
 	s.peerConnection.OnICEConnectionStateChange(func(connectionState webrtc.ICEConnectionState) {
 		fmt.Printf("ICE Connection State has changed: %s\n", connectionState.String())
-		fmt.Printf("Connection state is %v\n", s.peerConnection.ConnectionState)
 		if connectionState == webrtc.ICEConnectionStateDisconnected {
 			s.stopSending <- struct{}{}
 		}
@@ -25,10 +24,9 @@ func (s *Session) writeToNetwork() {
 	defer fmt.Println("Stopped sending data...")
 
 	for {
-	SELECT:
 		select {
 		case <-s.stopSending:
-			fmt.Printf("Pausing network I/O... (remaining at least %v packets)", len(s.output))
+			fmt.Printf("Pausing network I/O... (remaining at least %v packets)\n", len(s.output))
 			return
 		case data := <-s.output:
 			if data.n == 0 {
@@ -41,13 +39,6 @@ func (s *Session) writeToNetwork() {
 
 			for len(s.msgToBeSent) != 0 {
 				cur := s.msgToBeSent[0]
-
-				// TODO: Correct check
-				if s.dataChannel.ReadyState != webrtc.DataChannelStateOpen {
-					fmt.Printf("Status: %v, dropping %v bytes\n", s.dataChannel.ReadyState, data.n)
-					break SELECT
-				}
-
 				// Writing packet
 				if err := s.dataChannel.Send(cur.buff); err != nil {
 					fmt.Printf("Error, cannot send to client: %v\n", err)