286 lines
6.9 KiB
Go
286 lines
6.9 KiB
Go
package main
|
|
|
|
// Lot's of learning right out of the gate:
|
|
// https://stackoverflow.com/questions/51472020/how-to-get-the-size-of-available-tcp-data
|
|
|
|
import (
|
|
"bufio"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net"
|
|
"os"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
type Conf struct {
|
|
Port uint `yaml:"port,omitempty"`
|
|
Mailer struct {
|
|
ApiKey string `yaml:"api_key,omitempty"`
|
|
From string `yaml:"from,omitempty"`
|
|
}
|
|
}
|
|
|
|
type bufferedConn struct {
|
|
r *bufio.Reader
|
|
rout io.Reader
|
|
net.Conn
|
|
}
|
|
|
|
func newBufferedConn(c net.Conn) bufferedConn {
|
|
return bufferedConn{bufio.NewReader(c), nil, c}
|
|
}
|
|
|
|
func (b bufferedConn) Peek(n int) ([]byte, error) {
|
|
return b.r.Peek(n)
|
|
}
|
|
|
|
func (b bufferedConn) Buffered() (int) {
|
|
return b.r.Buffered()
|
|
}
|
|
|
|
func (b bufferedConn) Read(p []byte) (int, error) {
|
|
if b.rout != nil {
|
|
return b.rout.Read(p)
|
|
}
|
|
return b.r.Read(p)
|
|
}
|
|
|
|
type myMsg struct {
|
|
sender net.Conn
|
|
bytes []byte
|
|
receivedAt time.Time
|
|
}
|
|
|
|
var firstMsgs chan myMsg
|
|
var myMsgs chan myMsg
|
|
var myUnsortedConns map[net.Conn]bool
|
|
var myRawConns map[net.Conn]bool
|
|
var newConns chan net.Conn
|
|
|
|
func usage() {
|
|
fmt.Fprintf(os.Stderr, "\nusage: go run chatserver.go\n")
|
|
flag.PrintDefaults();
|
|
fmt.Println()
|
|
|
|
os.Exit(1)
|
|
}
|
|
|
|
func handleRaw(conn bufferedConn) {
|
|
// TODO
|
|
// What happens if this is being read from range
|
|
// when it's being added here (data race)?
|
|
// Should I use a channel here instead?
|
|
// TODO see https://jameshfisher.com/2017/04/18/golang-tcp-server.html
|
|
myRawConns[conn] = true
|
|
|
|
// Handle all subsequent packets
|
|
buf := make([]byte, 1024)
|
|
for {
|
|
fmt.Fprintf(os.Stdout, "[raw] Waiting for message...\n");
|
|
count, err := conn.Read(buf)
|
|
if nil != err {
|
|
if io.EOF != err {
|
|
fmt.Fprintf(os.Stderr, "Non-EOF socket error: %s\n", err)
|
|
}
|
|
fmt.Fprintf(os.Stdout, "Ending socket\n")
|
|
break
|
|
}
|
|
// Fun fact: if the buffer's current length (not capacity) is 0
|
|
// then the Read returns 0 without error
|
|
if 0 == count {
|
|
fmt.Fprintf(os.Stdout, "Weird")
|
|
continue
|
|
}
|
|
fmt.Fprintf(os.Stdout, "Queing message...\n");
|
|
myMsgs <- myMsg{
|
|
receivedAt: time.Now(),
|
|
sender: conn,
|
|
bytes: buf[0:count],
|
|
}
|
|
}
|
|
}
|
|
|
|
func handleSorted(conn bufferedConn) {
|
|
// at this piont we've already at least one byte via Peek()
|
|
// so the first packet is available in the buffer
|
|
n := conn.Buffered()
|
|
firstMsg, err := conn.Peek(n)
|
|
if nil != err {
|
|
panic(err)
|
|
}
|
|
firstMsgs <- myMsg{
|
|
receivedAt: time.Now(),
|
|
sender: conn,
|
|
bytes: firstMsg,
|
|
}
|
|
|
|
// TODO
|
|
// * TCP-CHAT
|
|
// * HTTP
|
|
// * TLS
|
|
|
|
// Handle all subsequent packets
|
|
buf := make([]byte, 1024)
|
|
for {
|
|
fmt.Fprintf(os.Stdout, "[sortable] Waiting for message...\n");
|
|
count, err := conn.Read(buf)
|
|
if nil != err {
|
|
if io.EOF != err {
|
|
fmt.Fprintf(os.Stderr, "Non-EOF socket error: %s\n", err)
|
|
}
|
|
fmt.Fprintf(os.Stdout, "Ending socket\n")
|
|
break
|
|
}
|
|
// Fun fact: if the buffer's current length (not capacity) is 0
|
|
// then the Read returns 0 without error
|
|
if 0 == count {
|
|
// fmt.Fprintf(os.Stdout, "Weird")
|
|
continue
|
|
}
|
|
myMsgs <- myMsg{
|
|
receivedAt: time.Now(),
|
|
sender: conn,
|
|
bytes: buf[0:count],
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO https://github.com/polvi/sni
|
|
func handleConnection(conn net.Conn) {
|
|
fmt.Fprintf(os.Stdout, "Accepting socket\n")
|
|
|
|
m := sync.Mutex{}
|
|
virgin := true
|
|
myUnsortedConns[conn] = true
|
|
|
|
// Why don't these work?
|
|
//buf := make([]byte, 0, 1024)
|
|
//buf := []byte{}
|
|
// But this does
|
|
|
|
bufConn := newBufferedConn(conn)
|
|
go func() {
|
|
// Handle First Packet
|
|
fmsg, err := bufConn.Peek(1)
|
|
if nil != err {
|
|
panic(err)
|
|
}
|
|
fmt.Fprintf(os.Stdout, "[First Byte] %s\n", fmsg)
|
|
|
|
m.Lock();
|
|
if virgin {
|
|
virgin = false
|
|
go handleSorted(bufConn)
|
|
} else {
|
|
go handleRaw(bufConn)
|
|
}
|
|
m.Unlock();
|
|
}()
|
|
|
|
time.Sleep(250 * 1000000)
|
|
// If we still haven't received data from the client
|
|
// assume that the client must be expecting a welcome from us
|
|
m.Lock()
|
|
if virgin {
|
|
virgin = false
|
|
// don't block for this
|
|
// let it be handled after the unlock
|
|
defer fmt.Fprintf(conn, "Welcome! This is an open relay chat server. There is no security yet.\n")
|
|
}
|
|
m.Unlock()
|
|
}
|
|
|
|
func main() {
|
|
flag.Usage = usage
|
|
port := flag.Uint("telnet-port", 0, "tcp telnet chat port")
|
|
confname := flag.String("config", "./config.yml", "ymal config file")
|
|
flag.Parse()
|
|
|
|
var config Conf
|
|
confstr, err := ioutil.ReadFile(*confname)
|
|
fmt.Fprintf(os.Stdout, "-config=%s\n", *confname)
|
|
if nil != err {
|
|
fmt.Fprintf(os.Stderr, "%s\nUsing defaults instead\n", err)
|
|
confstr = []byte("{\"port\":" + strconv.Itoa(int(*port)) + "}")
|
|
}
|
|
err = yaml.Unmarshal(confstr, &config)
|
|
if nil != err {
|
|
config = Conf{}
|
|
}
|
|
|
|
firstMsgs = make(chan myMsg, 128)
|
|
myMsgs = make(chan myMsg, 128)
|
|
newConns = make(chan net.Conn, 128)
|
|
myRawConns = make(map[net.Conn]bool)
|
|
myUnsortedConns = make(map[net.Conn]bool)
|
|
|
|
var addr string
|
|
if 0 != int(*port) {
|
|
addr = ":" + strconv.Itoa(int(*port))
|
|
} else {
|
|
addr = ":" + strconv.Itoa(int(config.Port))
|
|
}
|
|
|
|
// https://golang.org/pkg/net/#Conn
|
|
sock, err := net.Listen("tcp", addr)
|
|
if nil != err {
|
|
fmt.Fprintf(os.Stderr, "Couldn't bind to TCP socket %q: %s\n", addr, err)
|
|
os.Exit(2)
|
|
}
|
|
fmt.Println("Listening on", addr);
|
|
|
|
go func() {
|
|
for {
|
|
conn, err := sock.Accept()
|
|
if err != nil {
|
|
// Not sure what kind of error this could be or how it could happen.
|
|
// Could a connection abort or end before it's handled?
|
|
fmt.Fprintf(os.Stderr, "Error accepting connection:\n%s\n", err)
|
|
}
|
|
newConns <- conn
|
|
}
|
|
}()
|
|
|
|
for {
|
|
select {
|
|
case conn := <- newConns:
|
|
ts := time.Now()
|
|
fmt.Fprintf(os.Stdout, "[Handle New Connection] [Timestamp] %s\n", ts)
|
|
go handleConnection(conn)
|
|
case msg := <- myMsgs:
|
|
ts, err := msg.receivedAt.MarshalJSON()
|
|
if nil != err {
|
|
fmt.Fprintf(os.Stderr, "[Error] %s\n", err)
|
|
}
|
|
fmt.Fprintf(os.Stdout, "[Timestamp] %s\n", ts)
|
|
fmt.Fprintf(os.Stdout, "[Remote] %s\n", msg.sender.RemoteAddr().String())
|
|
fmt.Fprintf(os.Stdout, "[Message] %s\n", msg.bytes);
|
|
for conn, _ := range myRawConns {
|
|
if msg.sender == conn {
|
|
continue
|
|
}
|
|
// backlogged connections could prevent a next write,
|
|
// so this should be refactored into a goroutine
|
|
// And what to do about slow clients that get behind (or DoS)?
|
|
// SetDeadTime and Disconnect them?
|
|
conn.Write(msg.bytes)
|
|
}
|
|
case msg := <- firstMsgs:
|
|
fmt.Fprintf(os.Stdout, "f [First Message]\n")
|
|
ts, err := msg.receivedAt.MarshalJSON()
|
|
if nil != err {
|
|
fmt.Fprintf(os.Stderr, "f [Error] %s\n", err)
|
|
}
|
|
fmt.Fprintf(os.Stdout, "f [Timestamp] %s\n", ts)
|
|
fmt.Fprintf(os.Stdout, "f [Remote] %s\n", msg.sender.RemoteAddr().String())
|
|
fmt.Fprintf(os.Stdout, "f [Message] %s\n", msg.bytes);
|
|
}
|
|
}
|
|
}
|