Pushing beta version for clients and servers :) It works haha. Tests are still very much required

Author: 0x19

client.go

@@ -5,3 +5,100 @@
 // MIT License
 
 package goesl
+
+import (
+	"bufio"
+	"fmt"
+	"time"
+)
+
+// Client - In case you need to do inbound dialing against freeswitch server in order to originate call or see
+// sofia statuses or whatever else you came up with
+type Client struct {
+	SocketConnection
+
+	Proto   string `json:"freeswitch_protocol"`
+	Addr    string `json:"freeswitch_addr"`
+	Passwd  string `json:"freeswitch_password"`
+	Timeout int    `json:"freeswitch_connection_timeout"`
+}
+
+// EstablishConnection - Will attempt to establish connection against freeswitch and create new SocketConnection
+func (c *Client) EstablishConnection() error {
+	conn, err := c.Dial(c.Proto, c.Addr, time.Duration(c.Timeout*int(time.Second)))
+
+	c.SocketConnection = SocketConnection{
+		Conn: conn,
+		err:  make(chan error),
+		m:    make(chan *Message),
+	}
+
+	return err
+}
+
+// Authenticate - Method used to authenticate client against freeswitch. In case of any errors durring so
+// we will return error.
+func (c *Client) Authenticate() error {
+
+	m, err := newMessage(bufio.NewReaderSize(c, ReadBufferSize), false)
+
+	if err != nil {
+		Error(ECouldNotCreateMessage, err)
+		return err
+	}
+
+	cmr, err := m.tr.ReadMIMEHeader()
+
+	Debug("A: %v %v ", cmr, err)
+
+	if err != nil && err.Error() != "EOF" {
+		c.Close()
+		Error(ECouldNotReadMIMEHeaders, err)
+		return err
+	}
+
+	if cmr.Get("Content-Type") != "auth/request" {
+		c.Close()
+		Error(EUnexpectedAuthHeader, cmr.Get("Content-Type"))
+		return fmt.Errorf(EUnexpectedAuthHeader, cmr.Get("Content-Type"))
+	}
+
+	fmt.Fprintf(c, "auth %s\r\n\r\n", c.Passwd)
+
+	am, err := m.tr.ReadMIMEHeader()
+
+	if err != nil && err.Error() != "EOF" {
+		c.Close()
+		Error(ECouldNotReadMIMEHeaders, err)
+		return err
+	}
+
+	if am.Get("Reply-Text") != "+OK accepted" {
+		c.Close()
+		Error(EInvalidPassword, c.Passwd)
+		return fmt.Errorf(EInvalidPassword, c.Passwd)
+	}
+
+	return nil
+}
+
+// NewClient - Will initiate new client that will establish connection and attempt to authenticate
+// against connected freeswitch server
+func NewClient(host string, port uint, passwd string, timeout int) (Client, error) {
+	client := Client{
+		Proto:   "tcp", // Let me know if you ever need this open up lol
+		Addr:    fmt.Sprintf("%s:%d", host, port),
+		Passwd:  passwd,
+		Timeout: timeout,
+	}
+
+	if err := client.EstablishConnection(); err != nil {
+		return client, err
+	}
+
+	if err := client.Authenticate(); err != nil {
+		return client, err
+	}
+
+	return client, nil
+}

config.go

@@ -13,6 +13,7 @@ import (
 	"net"
 	"strconv"
 	"strings"
+	"time"
 )
 
 // Main connection against ESL - Gotta add more description here
@@ -22,6 +23,11 @@ type SocketConnection struct {
 	m   chan *Message
 }
 
+// Dial - Will establish timedout dial against specified address. In this case, it will be freeswitch server
+func (c *SocketConnection) Dial(network string, addr string, timeout time.Duration) (net.Conn, error) {
+	return net.DialTimeout(network, addr, timeout)
+}
+
 // Send - Will send raw message to open net connection
 func (c *SocketConnection) Send(cmd string) error {
 
@@ -139,7 +145,7 @@ func (c *SocketConnection) Handle() {
 
 	go func() {
 		for {
-			msg, err := newMessage(bufio.NewReaderSize(c, ReadBufferSize))
+			msg, err := newMessage(bufio.NewReaderSize(c, ReadBufferSize), true)
 
 			if err != nil {
 				c.err <- err

connection.go

@@ -17,4 +17,7 @@ var (
 	ECouldNotStartListener   = "Got error while attempting to start listener: %s"
 	EListenerConnection      = "Listener connection error: %s"
 	EInvalidServerAddr       = "Please make sure to pass along valid address. You've passed: \"%s\""
+	EUnexpectedAuthHeader    = "Expected auth/request content type. Got %s"
+	EInvalidPassword         = "Could not authenticate against freeswitch with provided password: %s"
+	ECouldNotCreateMessage   = "Error while creating new message: %s"
 )

errors.go

@@ -1,3 +1,4 @@
 server
 server_playback
-server_tts
+server_tts
+client

examples/.gitignore

@@ -7,15 +7,56 @@
 package main
 
 import (
+	"flag"
+	"fmt"
 	. "github.com/0x19/goesl"
 	"runtime"
+	"strings"
 )
 
+var (
+	fshost   = flag.String("fshost", "localhost", "Freeswitch hostname. Default: localhost")
+	fsport   = flag.Uint("fsport", 8021, "Freeswitch port. Default: 8021")
+	password = flag.String("pass", "ClueCon", "Freeswitch password. Default: ClueCon")
+	timeout  = flag.Int("timeout", 10, "Freeswitch conneciton timeout in seconds. Default: 10")
+)
+
+// Small client that will first make sure all events are returned as JSON and second, will originate
 func main() {
 
 	// Boost it as much as it can go ...
 	runtime.GOMAXPROCS(runtime.NumCPU())
 
-	Debug("While thinking what to do, this is how many CPU threads we got: %d", runtime.NumCPU())
+	client, err := NewClient(*fshost, *fsport, *password, *timeout)
+
+	if err != nil {
+		Error("Error while creating new client: %s", err)
+		return
+	}
+
+	Debug("Yuhu! New client: %q", client)
+
+	// Apparently all is good... Let us now handle connection :)
+	// We don't want this to be inside of new connection as who knows where it my lead us.
+	// Remember that this is crutial part in handling incoming messages :)
+	go client.Handle()
+
+	client.Send("events json ALL")
+
+	client.BgApi(fmt.Sprintf("originate %s %s", "sofia/internal/[email protected]", "&socket(192.168.1.2:8084 async full)"))
+
+	for {
+		msg, err := client.ReadMessage()
+
+		if err != nil {
+
+			// If it contains EOF, we really dont care...
+			if !strings.Contains(err.Error(), "EOF") && err.Error() != "unexpected end of JSON input" {
+				Error("Error while reading Freeswitch message: %s", err)
+			}
+			break
+		}
 
+		Debug("%s", msg)
+	}
 }

examples/client.go

@@ -14,9 +14,7 @@ import (
 	"strings"
 )
 
-var (
-	welcomeFile = "%s/media/welcome.wav"
-)
+var welcomeFile = "%s/media/welcome.wav"
 
 func main() {
 
@@ -47,69 +45,69 @@ func main() {
 
 }
 
-// handle - Running under goroutine here to explain how to send message, receive message and in general dump stuff out
+// handle - Running under goroutine here to explain how to handle playback ( play to the caller )
 func handle(s *OutboundServer) {
 
 	for {
 
-		conn := <-s.Conns
-
-		Notice("New incomming connection: %v", conn)
-
-		conn.Send("connect")
-
-		aMsg, err := conn.Execute("answer", "", false)
+		select {
 
-		if err != nil {
-			Error("Got error while executing answer against call: %s", err)
-			break
-		}
-
-		Debug("Answer Message: %s", aMsg)
-		Debug("Caller UUID: %s", aMsg.GetHeader("Caller-Unique-Id"))
+		case conn := <-s.Conns:
+			Notice("New incomming connection: %v", conn)
 
-		cUUID := aMsg.GetHeader("Caller-Unique-Id")
-
-		pMsg, err := conn.Execute("playback", welcomeFile, true)
+			if err := conn.Connect(); err != nil {
+				Error("Got error while accepting connection: %s", err)
+				break
+			}
 
-		if err != nil {
-			Error("Got error while executing answer against call: %s", err)
-			break
-		}
+			answer, err := conn.ExecuteAnswer("", false)
 
-		Debug("Playback Message: %s", pMsg)
+			if err != nil {
+				Error("Got error while executing answer: %s", err)
+				break
+			}
 
-		hMsg, err := conn.ExecuteUUID(cUUID, "hangup", "", false)
+			Debug("Answer Message: %s", answer)
+			Debug("Caller UUID: %s", answer.GetHeader("Caller-Unique-Id"))
 
-		if err != nil {
-			Error("Got error while executing hangup against call: %s", err)
-			break
-		}
+			cUUID := answer.GetCallUUID()
 
-		Debug("Hangup Message: %s", hMsg)
+			if sm, err := conn.Execute("playback", welcomeFile, true); err != nil {
+				Error("Got error while executing playback: %s", err)
+				break
+			} else {
+				Debug("Playback Message: %s", sm)
+			}
 
-		done := make(chan bool)
+			if hm, err := conn.ExecuteHangup(cUUID, "", false); err != nil {
+				Error("Got error while executing hangup: %s", err)
+				break
+			} else {
+				Debug("Hangup Message: %s", hm)
+			}
 
-		go func() {
-			for {
-				msg, err := conn.ReadMessage()
+			go func() {
+				for {
+					msg, err := conn.ReadMessage()
 
-				if err != nil {
+					if err != nil {
 
-					// If it contains EOF, we really dont care...
-					if !strings.Contains(err.Error(), "EOF") {
-						Error("Error while reading Freeswitch message: %s", err)
+						// If it contains EOF, we really dont care...
+						if !strings.Contains(err.Error(), "EOF") {
+							Error("Error while reading Freeswitch message: %s", err)
+						}
+						break
 					}
 
-					done <- true
-					break
+					Debug("%s", msg)
 				}
+			}()
 
-				Info("%s", msg.Dump())
-			}
-		}()
-
-		<-done
+		default:
+			// YabbaDabbaDooooo!
+			//Flintstones. Meet the Flintstones. They're the modern stone age family. From the town of Bedrock,
+			// They're a page right out of history. La la,lalalalala la :D
+		}
 	}
 
 }

examples/server_playback.go

@@ -102,7 +102,7 @@ func handle(s *OutboundServer) {
 						break
 					}
 
-					Debug("%s", msg.Dump())
+					Debug("%s", msg)
 				}
 			}()
 

examples/server_tts.go

@@ -4,8 +4,6 @@
 // I didn't write all of this code so you could say it's yours.
 // MIT License
 
-// This package is used to set helpers for common applications/send that we may use such as set variable against dialplan or accepting connection
-
 package goesl
 
 import "fmt"
@@ -29,6 +27,16 @@ func (sc *SocketConnection) ExecuteHangup(uuid string, args string, sync bool) (
 	return sc.Execute("hangup", args, sync)
 }
 
+// BgApi - Helper designed to attach api in front of the command so that you do not need to write it
+func (sc *SocketConnection) Api(command string) error {
+	return sc.Send(fmt.Sprintf("api %s", command))
+}
+
+// BgApi - Helper designed to attach bgapi in front of the command so that you do not need to write it
+func (sc *SocketConnection) BgApi(command string) error {
+	return sc.Send(fmt.Sprintf("bgapi %s", command))
+}
+
 // Connect - Helper designed to help you handle connection. Each outbound server when handling needs to connect e.g. accept
 // connection in order for you to do answer, hangup or do whatever else you wish to do
 func (sc *SocketConnection) Connect() error {