Tucked dbg{client/server} away for testing

This commit is contained in:
Russ Magee 2018-01-12 22:47:57 -08:00
parent 9b3bd6b78b
commit 78edf1c130
4 changed files with 142 additions and 9 deletions

View file

@ -3,6 +3,8 @@ package main
import ( import (
"flag" "flag"
"fmt" "fmt"
"io"
"os"
hkex "blitter.com/herradurakex" hkex "blitter.com/herradurakex"
) )
@ -17,7 +19,7 @@ func main() {
var cAlg string var cAlg string
var hAlg string var hAlg string
var server string var server string
flag.StringVar(&cAlg, "c", "C_AES_256", "cipher [\"C_AES_256\" | \"C_TWOFISH_128\" | \"C_BLOWFISH_64\"]") flag.StringVar(&cAlg, "c", "C_AES_256", "cipher [\"C_AES_256\" | \"C_TWOFISH_128\" | \"C_BLOWFISH_64\"]")
flag.StringVar(&hAlg, "h", "H_SHA256", "hmac [\"H_SHA256\"]") flag.StringVar(&hAlg, "h", "H_SHA256", "hmac [\"H_SHA256\"]")
flag.StringVar(&server, "s", "localhost:2000", "server hostname/address[:port]") flag.StringVar(&server, "s", "localhost:2000", "server hostname/address[:port]")
@ -25,13 +27,11 @@ func main() {
conn, err := hkex.Dial("tcp", server, cAlg, hAlg) conn, err := hkex.Dial("tcp", server, cAlg, hAlg)
if err != nil { if err != nil {
// handle error
fmt.Println("Err!") fmt.Println("Err!")
panic(err)
}
_, err = io.Copy(conn, os.Stdin)
if err != nil && err.Error() != "EOF" {
fmt.Println(err)
} }
fmt.Fprintf(conn, "\x01\x02\x03\x04")
//fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
//status, err := bufio.NewReader(conn).ReadString('\n')
//_, err = bufio.NewReader(conn).ReadString('\n')
// ...
} }

37
demo/dbgclient/client.go Normal file
View file

@ -0,0 +1,37 @@
package main
import (
"flag"
"fmt"
"io"
"os"
hkex "blitter.com/herradurakex"
)
// Demo of a simple client that dials up to a simple test server to
// send data.
// Note this code is identical to standard tcp client code, save for
// declaring a 'hkex' rather than a 'net' Dialer Conn. The KEx and
// encrypt/decrypt is done within the type.
// Compare to 'clientp.go' in this directory to see the equivalence.
func main() {
var cAlg string
var hAlg string
var server string
flag.StringVar(&cAlg, "c", "C_AES_256", "cipher [\"C_AES_256\" | \"C_TWOFISH_128\" | \"C_BLOWFISH_64\"]")
flag.StringVar(&hAlg, "h", "H_SHA256", "hmac [\"H_SHA256\"]")
flag.StringVar(&server, "s", "localhost:2000", "server hostname/address[:port]")
flag.Parse()
conn, err := hkex.Dial("tcp", server, cAlg, hAlg)
if err != nil {
fmt.Println("Err!")
panic(err)
}
_, err = io.Copy(conn, os.Stdin)
if err != nil && err.Error() != "EOF" {
fmt.Println(err)
}
}

View file

@ -62,7 +62,7 @@ func main() {
} }
}(ch, eCh) }(ch, eCh)
ticker := time.Tick(time.Second) ticker := time.Tick(time.Second/100)
Term: Term:
// continuously read from the connection // continuously read from the connection
for { for {

96
demo/server/server.go Normal file
View file

@ -0,0 +1,96 @@
package main
import (
"flag"
"fmt"
"log"
"time"
hkex "blitter.com/herradurakex"
)
// Demo of a simple server that listens and spawns goroutines for each
// connecting client. Note this code is identical to standard tcp
// server code, save for declaring 'hkex' rather than 'net'
// Listener and Conns. The KEx and encrypt/decrypt is done within the type.
// Compare to 'serverp.go' in this directory to see the equivalence.
func main() {
var laddr string
flag.StringVar(&laddr, "l", ":2000", "interface[:port] to listen")
flag.Parse()
// Listen on TCP port 2000 on all available unicast and
// anycast IP addresses of the local system.
l, err := hkex.Listen("tcp", laddr)
if err != nil {
log.Fatal(err)
}
defer l.Close()
fmt.Println("Serving on", laddr)
for {
// Wait for a connection.
conn, err := l.Accept()
if err != nil {
log.Fatal(err)
}
fmt.Println("Accepted client")
// Handle the connection in a new goroutine.
// The loop then returns to accepting, so that
// multiple connections may be served concurrently.
go func(c hkex.Conn) (e error) {
ch := make(chan []byte)
chN := 0
eCh := make(chan error)
// Start a goroutine to read from our net connection
go func(ch chan []byte, eCh chan error) {
for {
// try to read the data
data := make([]byte, 512)
chN, err = c.Read(data)
if err != nil {
// send an error if it's encountered
eCh <- err
return
}
// send data if we read some.
ch <- data[0:chN]
}
}(ch, eCh)
ticker := time.Tick(time.Second/100)
Term:
// continuously read from the connection
for {
select {
// This case means we recieved data on the connection
case data := <-ch:
// Do something with the data
fmt.Printf("Client sent %+v\n", data[0:chN])
//fmt.Printf("Client sent %s\n", string(data))
// This case means we got an error and the goroutine has finished
case err := <-eCh:
// handle our error then exit for loop
if err.Error() == "EOF" {
fmt.Printf("[Client disconnected]\n")
} else {
fmt.Printf("Error reading client data! (%+v)\n", err)
}
break Term
// This will timeout on the read.
case <-ticker:
// do nothing? this is just so we can time out if we need to.
// you probably don't even need to have this here unless you want
// do something specifically on the timeout.
}
}
// Shut down the connection.
c.Close()
return
}(conn)
}
}