Initial implementation

Author: aprice

README.md

@@ -0,0 +1,48 @@
+# Package telnet
+
+The [`telnet` package](http://godoc.org/github.com/aprice/telnet) provides basic
+telnet client and server implementations for Go, including handling of IACs and
+extensible telnet option negotiation.
+
+Currently both the basic client and server are implemented, as well as a NAWS
+client/server handler as a working example. Additional handlers may be added to
+the core library over time (feel free to submit a PR if you've written one you'd
+like to see added!)
+
+## Usage
+
+Running a server:
+```go
+svr := telnet.NewServer(":9999", telnet.HandleFunc(func(c *telnet.Connection){
+	log.Printf("Connection received: %s", c.RemoteAddr())
+	c.Write([]byte("Hello world!\r\n"))
+	c.Close()
+}))
+svr.ListenAndServe()
+```
+
+The server API is modeled after the `net/http` API, so it should be easy to get
+your bearings; of course, telnet and HTTP are very different beasts, so the
+similarities are somewhat limited. The server listens on a TCP address for new
+connections. Whenever a new connection is received, the connection handler is
+called with the connection object. This object is a wrapper for the underlying
+TCP connection, which aims to transparently handle IAC. There is a slightly
+more complex example located in the `example` package.
+
+Running a client is pretty simple:
+```go
+conn, err := telnet.Dial("127.0.0.1:9999")
+```
+
+This is really straightforward - dial out, get a telnet connection handler back.
+Again, this handles IAC transparently, and like the Server, can take a list of
+optional IAC handlers. Bear in mind that some handlers - for example, the
+included NAWS handler - use different Option functions to register them with a
+client versus a server; this is because they may behave differently at each end.
+See the documentation for the options for more details.
+
+## Linereader
+
+A sub-package, `linereader`, exposes a simple reader intended to be run in a
+Goroutine, which consumes lines from an `io.Reader` and sends them over a
+channel for asynchronous handling.

ansi.go

@@ -0,0 +1,56 @@
+package telnet
+
+// Telnet IAC constants
+const (
+	SE   = byte(240)
+	NOP  = byte(241)
+	BRK  = byte(243)
+	IP   = byte(244)
+	AO   = byte(245)
+	AYT  = byte(246)
+	EC   = byte(247)
+	EL   = byte(248)
+	GA   = byte(249)
+	SB   = byte(250)
+	WILL = byte(251)
+	WONT = byte(252)
+	DO   = byte(253)
+	DONT = byte(254)
+	IAC  = byte(255)
+)
+
+const Escape = byte('\033')
+
+// ANSI control sequences
+var (
+	// styles
+	Reset        = []byte("\033[0m")
+	Bold         = []byte("\033[1m")
+	Underline    = []byte("\033[4m")
+	Conceal      = []byte("\033[8m")
+	NormalWeight = []byte("\033[22m")
+	NoUnderline  = []byte("\033[24m")
+	Reveal       = []byte("\033[28m")
+	// colors - foreground
+	FGBlack   = []byte("\033[30m")
+	FGRed     = []byte("\033[31m")
+	FGGreen   = []byte("\033[32m")
+	FGYellow  = []byte("\033[33m")
+	FGBlue    = []byte("\033[34m")
+	FGMagenta = []byte("\033[35m")
+	FGCyan    = []byte("\033[36m")
+	FGWhite   = []byte("\033[37m")
+	FGDefault = []byte("\033[39m")
+	// background
+	BGBlack   = []byte("\033[40m")
+	BGRed     = []byte("\033[41m")
+	BGGreen   = []byte("\033[42m")
+	BGYellow  = []byte("\033[43m")
+	BGBlue    = []byte("\033[44m")
+	BGMagenta = []byte("\033[45m")
+	BGCyan    = []byte("\033[46m")
+	BGWhite   = []byte("\033[47m")
+	BGDefault = []byte("\033[49m")
+	// xterm
+	TitleBarFmt = "\033]0;%s\a"
+)

client.go

@@ -0,0 +1,17 @@
+package telnet
+
+import (
+	"net"
+)
+
+// Dial establishes a telnet connection with the remote host specified by addr
+// in host:port format. Any specified option handlers will be applied to the
+// connection if it is successful.
+func Dial(addr string, options ...Option) (conn *Connection, err error) {
+	c, err := net.Dial("tcp", addr)
+	if err != nil {
+		return
+	}
+	conn = NewConnection(c, options)
+	return
+}

connection.go

@@ -0,0 +1,239 @@
+package telnet
+
+import (
+	"fmt"
+	"net"
+	"time"
+)
+
+// Negotiator defines the requirements for a telnet option handler.
+type Negotiator interface {
+	// OptionCode returns the 1-byte option code that indicates this option.
+	OptionCode() byte
+	// Offer is called when a new connection is initiated. It offers the handler
+	// an opportunity to advertise or request an option.
+	Offer(conn *Connection)
+	// HandleDo is called when an IAC DO command is received for this option,
+	// indicating the client is requesting the option to be enabled.
+	HandleDo(conn *Connection)
+	// HandleWill is called when an IAC WILL command is received for this
+	// option, indicating the client is willing to enable this option.
+	HandleWill(conn *Connection)
+	// HandleSB is called when a subnegotiation command is received for this
+	// option. body contains the bytes between `IAC SB <OptionCode>` and `IAC
+	// SE`.
+	HandleSB(conn *Connection, body []byte)
+}
+
+// Connection to the telnet server. This lightweight TCPConn wrapper handles
+// telnet control sequences transparently in reads and writes, and provides
+// handling of supported options.
+type Connection struct {
+	// The underlying network connection.
+	net.Conn
+
+	// OptionHandlers handle IAC options; the key is the IAC option code.
+	OptionHandlers map[byte]Negotiator
+
+	// Read buffer
+	buf  []byte
+	r, w int // buf read and write positions
+
+	// IAC handling
+	iac    bool
+	cmd    byte
+	option byte
+
+	// Known client wont/dont
+	clientWont map[byte]bool
+	clientDont map[byte]bool
+}
+
+// NewConnection initializes a new Connection for this given TCPConn. It will
+// register all the given Option handlers and call Offer() on each, in order.
+func NewConnection(c net.Conn, options []Option) *Connection {
+	conn := &Connection{
+		Conn:           c,
+		OptionHandlers: make(map[byte]Negotiator, len(options)),
+		buf:            make([]byte, 256),
+		clientWont:     make(map[byte]bool),
+		clientDont:     make(map[byte]bool),
+	}
+	for _, o := range options {
+		h := o(conn)
+		conn.OptionHandlers[h.OptionCode()] = h
+		h.Offer(conn)
+	}
+	return conn
+}
+
+// Write to the connection, escaping IAC as necessary.
+func (c *Connection) Write(b []byte) (n int, err error) {
+	var nn, lastWrite int
+	for i, ch := range b {
+		if ch == IAC {
+			if lastWrite < i-1 {
+				nn, err = c.Conn.Write(b[lastWrite:i])
+				n += nn
+				if err != nil {
+					return
+				}
+			}
+			lastWrite = i + 1
+			nn, err = c.Conn.Write([]byte{IAC, IAC})
+			n += nn
+			if err != nil {
+				return
+			}
+		}
+	}
+	if lastWrite < len(b) {
+		nn, err = c.Conn.Write(b[lastWrite:])
+		n += nn
+	}
+	return
+}
+
+// RawWrite writes raw data to the connection, without escaping done by Write.
+// Use of RawWrite over Conn.Write allows Connection to do any additional
+// handling necessary, so long as it does not modify the raw data sent.
+func (c *Connection) RawWrite(b []byte) (n int, err error) {
+	return c.Conn.Write(b)
+}
+
+const maxReadAttempts = 10
+
+// Read from the connection, transparently removing and handling IAC control
+// sequences. It may attempt multiple reads against the underlying connection if
+// it receives back only IAC which gets stripped out of the stream.
+func (c *Connection) Read(b []byte) (n int, err error) {
+	for i := 0; i < maxReadAttempts && n == 0 && len(b) > 0; i++ {
+		n, err = c.read(b)
+	}
+	return
+}
+
+func (c *Connection) read(b []byte) (n int, err error) {
+	err = c.fill(len(b))
+	if err != nil {
+		return
+	}
+	var lastWrite, subStart int
+	var ignoreIAC bool
+	write := func(end int) int {
+		if c.r == end {
+			return 0
+		}
+		nn := copy(b[lastWrite:], c.buf[c.r:end])
+		n += nn
+		lastWrite += nn
+		c.r += nn
+		return nn
+	}
+	endIAC := func(i int) {
+		subStart = 0
+		c.iac = false
+		c.cmd = 0
+		c.option = 0
+		c.r = i + 1
+	}
+	for i := c.r; i < c.w && lastWrite < len(b); i++ {
+		ch := c.buf[i]
+		if ch == IAC && !ignoreIAC {
+			if c.iac && c.cmd == 0 {
+				// Escaped IAC in text
+				write(i)
+				c.r++
+				c.iac = false
+				continue
+			} else if c.iac && c.buf[i-1] == IAC {
+				// Escaped IAC inside IAC sequence
+				copy(c.buf[:i], c.buf[i+1:])
+				i--
+				ignoreIAC = true
+				continue
+			} else if !c.iac {
+				// Start of IAC sequence
+				write(i)
+				c.iac = true
+				continue
+			}
+		}
+
+		ignoreIAC = false
+
+		if c.iac && c.cmd == 0 {
+			c.cmd = ch
+			if ch == SB {
+				subStart = i + 2
+			}
+			continue
+		} else if c.iac && c.option == 0 {
+			c.option = ch
+			if c.cmd != SB {
+				c.handleNegotiation()
+				endIAC(i)
+			}
+			continue
+		} else if c.iac && c.cmd == SB && ch == SE && c.buf[i-1] == IAC {
+			if h, ok := c.OptionHandlers[c.option]; ok {
+				h.HandleSB(c, c.buf[subStart:i-1])
+			}
+			endIAC(i)
+			continue
+		}
+	}
+
+	nn := copy(b[lastWrite:], c.buf[c.r:c.w])
+	n += nn
+	c.r += nn
+	return
+}
+
+func (c *Connection) fill(requestedBytes int) error {
+	if c.r > 0 {
+		copy(c.buf, c.buf[c.r:])
+		c.w -= c.r
+		c.r = 0
+	}
+
+	if len(c.buf) < requestedBytes {
+		buf := make([]byte, requestedBytes)
+		c.w = copy(buf, c.buf[c.r:c.w])
+		c.r = 0
+		c.buf = buf
+	}
+
+	c.SetReadDeadline(time.Now().Add(time.Microsecond))
+	nn, err := c.Conn.Read(c.buf[c.w:])
+	c.SetReadDeadline(time.Time{})
+	c.w += nn
+	return err
+}
+
+// SetWindowTitle attempts to set the client's telnet window title. Clients may
+// or may not support this.
+func (c *Connection) SetWindowTitle(title string) {
+	fmt.Fprintf(c, TitleBarFmt, title)
+}
+
+func (c *Connection) handleNegotiation() {
+	switch c.cmd {
+	case WILL:
+		if h, ok := c.OptionHandlers[c.option]; ok {
+			h.HandleWill(c)
+		} else {
+			c.Conn.Write([]byte{IAC, DONT, c.option})
+		}
+	case WONT:
+		c.clientWont[c.option] = true
+	case DO:
+		if h, ok := c.OptionHandlers[c.option]; ok {
+			h.HandleDo(c)
+		} else {
+			c.Conn.Write([]byte{IAC, WONT, c.option})
+		}
+	case DONT:
+		c.clientDont[c.option] = true
+	}
+}

connection_test.go

@@ -0,0 +1,99 @@
+package telnet_test
+
+import (
+	"bytes"
+	"net"
+	"testing"
+
+	"github.com/aprice/telnet"
+)
+
+func TestConnection_Write(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []byte
+		expected []byte
+	}{
+		{
+			name:     "plain",
+			input:    []byte("hello world"),
+			expected: []byte("hello world"),
+		},
+		{
+			name:     "iac",
+			input:    []byte("hello \xffworld"),
+			expected: []byte("hello \xff\xffworld"),
+		},
+		{
+			name:     "doubleiac",
+			input:    []byte("hello \xff\xffworld"),
+			expected: []byte("hello \xff\xff\xff\xffworld"),
+		},
+	}
+	buf := bytes.NewBuffer(nil)
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			buf.Reset()
+			client, server := net.Pipe()
+			go func() {
+				conn := telnet.NewConnection(server, nil)
+				_, err := conn.Write(test.input)
+				if err != nil {
+					t.Error(err)
+				}
+				conn.Close()
+			}()
+			buf.ReadFrom(client)
+			client.Close()
+			if !bytes.Equal(test.expected, buf.Bytes()) {
+				t.Errorf("Expected %v, got %v", test.expected, buf.Bytes())
+			}
+		})
+	}
+}
+
+func TestConnection_Read(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []byte
+		expected []byte
+	}{
+		{
+			name:     "plain",
+			input:    []byte("hello world"),
+			expected: []byte("hello world"),
+		},
+		{
+			name:     "iac",
+			input:    []byte("hello \xff\xffworld"),
+			expected: []byte("hello \xffworld"),
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			client, server := net.Pipe()
+			go func() {
+				client.Write(test.input)
+				t.Log("Finished writing")
+				client.Close()
+				t.Log("Closed client")
+			}()
+			conn := telnet.NewConnection(server, nil)
+			b := make([]byte, len(test.expected))
+			_, err := conn.Read(b)
+			if err != nil {
+				t.Error(err)
+			}
+			conn.Close()
+			if !bytes.Equal(test.expected, b) {
+				t.Errorf("Expected %v, got %v", test.expected, b)
+			}
+		})
+	}
+}
+
+type closerBuf struct {
+	*bytes.Buffer
+}
+
+func (c *closerBuf) Close() error { return nil }

example/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"log"
+	"sync"
+	"time"
+
+	"github.com/aprice/telnet"
+	"github.com/aprice/telnet/linereader"
+)
+
+func main() {
+	svr := telnet.NewServer(":9999", telnet.HandleFunc(exampleHandler), telnet.NAWSOption)
+	svr.ListenAndServe()
+}
+
+func exampleHandler(c *telnet.Connection) {
+	log.Printf("Connection received: %s", c.RemoteAddr())
+	lr := linereader.New()
+	go lr.ReadLines(c)
+
+	wg := new(sync.WaitGroup)
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		for line := range lr.C {
+			log.Printf("Received line: %v", line)
+		}
+	}()
+	time.Sleep(time.Millisecond)
+	nh := c.OptionHandlers[telnet.NAWS].(*telnet.NAWSHandler)
+	log.Printf("Client width: %d, height: %d", nh.Width, nh.Height)
+	wg.Wait()
+	log.Printf("Goodbye %s!", c.RemoteAddr())
+}

linereader/linereader.go

@@ -0,0 +1,49 @@
+package linereader
+
+import (
+	"bufio"
+	"io"
+)
+
+// LineReader reads lines from an io.Reader and passes them to a channel.
+type LineReader struct {
+	C chan []byte
+}
+
+// New constructs a new LineReader. While the zero value is usable, it may
+// cause a race condition; it is better to call New() to initialize the channel
+// before calling ReadLines, to ensure that the channel is not nil when it is
+// first read.
+func New() *LineReader {
+	return &LineReader{C: make(chan []byte)}
+}
+
+// ReadLines continuously reads lines from the Reader and sends them on C. It
+// will not return until it encounters an error (including io.EOF).
+func (r *LineReader) ReadLines(in io.Reader) (err error) {
+	if r.C == nil {
+		r.C = make(chan []byte)
+	}
+	defer close(r.C)
+	rdr := bufio.NewReader(in)
+	var line, cont []byte
+	var prefix bool
+	for {
+		line, prefix, err = rdr.ReadLine()
+		for prefix && err == nil {
+			cont, prefix, err = rdr.ReadLine()
+			line = append(line, cont...)
+		}
+		if line != nil {
+			r.C <- line
+		}
+		if err == io.EOF {
+			err = nil
+			break
+		}
+		if err != nil {
+			break
+		}
+	}
+	return
+}

options.go

@@ -0,0 +1,92 @@
+package telnet
+
+import (
+	"encoding/binary"
+	"os"
+	"time"
+
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+const (
+	ECHO    = byte(1)
+	TTYPE   = byte(24)
+	NAWS    = byte(31)
+	ENCRYPT = byte(38)
+	EOR     = byte(239)
+)
+
+// NAWSOption enables NAWS negotiation on a Server.
+func NAWSOption(c *Connection) Negotiator {
+	return &NAWSHandler{client: false}
+}
+
+// ExposeNAWS enables NAWS negotiation on a Client.
+func ExposeNAWS(c *Connection) Negotiator {
+	width, height, _ := terminal.GetSize(int(os.Stdin.Fd()))
+	return &NAWSHandler{Width: uint16(width), Height: uint16(height), client: true}
+}
+
+// NAWSHandler negotiates NAWS for a specific connection.
+type NAWSHandler struct {
+	Width  uint16
+	Height uint16
+
+	client bool
+}
+
+func (n *NAWSHandler) OptionCode() byte {
+	return NAWS
+}
+
+func (n *NAWSHandler) Offer(c *Connection) {
+	if !n.client {
+		c.Conn.Write([]byte{IAC, DO, n.OptionCode()})
+	}
+}
+
+func (n *NAWSHandler) HandleWill(c *Connection) {}
+
+func (n *NAWSHandler) HandleDo(c *Connection) {
+	if n.client {
+		c.Conn.Write([]byte{IAC, WILL, n.OptionCode()})
+		n.writeSize(c)
+		go n.monitorTTYSize(c)
+	} else {
+		c.Conn.Write([]byte{IAC, WONT, n.OptionCode()})
+	}
+}
+
+func (n *NAWSHandler) monitorTTYSize(c *Connection) {
+	t := time.NewTicker(time.Second)
+	for range t.C {
+		w, h, err := terminal.GetSize(int(os.Stdin.Fd()))
+		if err != nil {
+			continue
+		}
+		width := uint16(w)
+		height := uint16(h)
+		if width != n.Width || height != n.Height {
+			n.Width = width
+			n.Height = height
+			n.writeSize(c)
+		}
+	}
+}
+
+func (n *NAWSHandler) writeSize(c *Connection) {
+	c.Conn.Write([]byte{IAC, SB, n.OptionCode()})
+	payload := make([]byte, 4)
+	binary.BigEndian.PutUint16(payload, n.Width)
+	binary.BigEndian.PutUint16(payload[2:], n.Height)
+	// Normal write - we want inadvertent IACs to be escaped in body
+	c.Write(payload)
+	c.Conn.Write([]byte{IAC, SE})
+}
+
+func (n *NAWSHandler) HandleSB(c *Connection, b []byte) {
+	if !n.client {
+		n.Width = binary.BigEndian.Uint16(b[0:2])
+		n.Height = binary.BigEndian.Uint16(b[2:4])
+	}
+}

options_test.go

@@ -0,0 +1,118 @@
+package telnet_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"net"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/aprice/telnet"
+)
+
+func TestServerNAWS(t *testing.T) {
+	client, server := net.Pipe()
+	text := []byte("hello\n")
+	wg := new(sync.WaitGroup)
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		defer client.Close()
+		b := make([]byte, 3)
+		_, err := client.Read(b)
+		if err != nil {
+			t.Error(err)
+		}
+		if !bytes.Equal(b, []byte{255, 253, 31}) {
+			t.Errorf("Expected IAC DO NAWS, received %v", b)
+		}
+		// IAC WILL NAWS IAC SB NAWS W[1] W[0] H[1] H[0] IAC SE
+		payload := []byte{255, 251, 31, 255, 250, 31, 0, 80, 0, 20, 255, 240}
+		payload = append(payload, text...)
+		_, err = client.Write(payload)
+		if err != nil {
+			t.Error(err)
+		}
+	}()
+	conn := telnet.NewConnection(server, []telnet.Option{telnet.NAWSOption})
+	b := make([]byte, 32)
+	n, err := conn.Read(b)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if !bytes.Equal(text, b[:n]) {
+		t.Errorf("Expected %q, got %q", text, b[:n])
+	}
+	wg.Wait()
+	conn.Close()
+
+	nw := conn.OptionHandlers[31].(*telnet.NAWSHandler)
+	if nw.Width != 80 || nw.Height != 20 {
+		t.Logf("%#v", conn)
+		t.Errorf("Expected w %d, h %d, got w %d, h %d", 80, 20, nw.Width, nw.Height)
+	}
+}
+
+func TestClientNAWS(t *testing.T) {
+	client, server := net.Pipe()
+	go func() {
+		conn := telnet.NewConnection(client, []telnet.Option{telnet.ExposeNAWS})
+		b := make([]byte, 32)
+		conn.Read(b)
+		conn.Close()
+	}()
+
+	_, err := server.Write([]byte{255, 253, 31})
+	if err != nil {
+		t.Error(err)
+	}
+	expected := []byte{255, 251, 31, 255, 250, 31, 255, 255, 255, 255, 255, 255, 255, 255, 255, 240}
+	buf := bytes.NewBuffer(nil)
+	server.SetReadDeadline(time.Now().Add(time.Second))
+	n, err := io.CopyN(buf, server, int64(len(expected)))
+	if err != nil {
+		t.Error(err)
+	}
+	b := buf.Bytes()
+	server.Close()
+	// IAC WILL NAWS IAC SB NAWS W[1] W[0] H[1] H[0] IAC SE
+	if !bytes.Equal(b[:n], expected) {
+		t.Errorf("Expected %v, received %v", expected, b[:n])
+	}
+}
+
+func TestOnlyServerSupportsNAWS(t *testing.T) {
+	client, server := net.Pipe()
+	text := []byte("hello\n")
+	wg := new(sync.WaitGroup)
+	wg.Add(1)
+	go func() {
+		conn := telnet.NewConnection(client, []telnet.Option{})
+		b := make([]byte, 32)
+		n, err := conn.Read(b)
+		if err != nil {
+			t.Error(err)
+		}
+		conn.Close()
+
+		if !bytes.Equal(text, b[:n]) {
+			t.Errorf("Expected %q, got %q", text, b[:n])
+		}
+		wg.Done()
+	}()
+	wg.Add(1)
+	go func() {
+		conn := telnet.NewConnection(server, []telnet.Option{telnet.NAWSOption})
+		go io.Copy(ioutil.Discard, conn)
+		_, err := conn.Write(text)
+		if err != nil {
+			t.Error(err)
+		}
+		conn.Close()
+		wg.Done()
+	}()
+	wg.Wait()
+}

server.go

@@ -0,0 +1,83 @@
+package telnet
+
+import (
+	"net"
+)
+
+// Option functions add handling of a telnet option to a Server. The Option
+// function takes a connection (which it can store but needn't) and returns a
+// Negotiator; it is up to the Option function whether a single instance of
+// the Negotiator is reused or if a new instance is created for each connection.
+type Option func(c *Connection) Negotiator
+
+// Handler is a telnet connection handler. The Handler passed to a server will
+// be called for all incoming connections.
+type Handler interface {
+	HandleTelnet(conn *Connection)
+}
+
+// HandleFunc makes it easy to pass a function as a Handler instead of a full
+// type.
+type HandleFunc func(conn *Connection)
+
+// HandleTelnet implements Handler, and simply calls the function.
+func (f HandleFunc) HandleTelnet(conn *Connection) {
+	f(conn)
+}
+
+// Server listens for telnet connections.
+type Server struct {
+	// Address is the addres the Server listens on.
+	Address  string
+	handler  Handler
+	options  []Option
+	listener net.Listener
+	quitting bool
+}
+
+// NewServer constructs a new telnet server.
+func NewServer(addr string, handler Handler, options ...Option) *Server {
+	return &Server{Address: addr, handler: handler, options: options}
+}
+
+// Serve runs the telnet server. This function does not return and
+// should probably be run in a goroutine.
+func (s *Server) Serve(l net.Listener) error {
+	s.listener = l
+	s.Address = s.listener.Addr().String()
+	for {
+		c, err := s.listener.Accept()
+		if err != nil {
+			if s.quitting {
+				return nil
+			}
+			return err
+		}
+		conn := NewConnection(c, s.options)
+		go func() {
+			s.handler.HandleTelnet(conn)
+			conn.Conn.Close()
+		}()
+	}
+}
+
+// ListenAndServe runs the telnet server by creating a new Listener using the
+// current Server.Address, and then calling Serve().
+func (s *Server) ListenAndServe() error {
+	l, err := net.Listen("tcp", s.Address)
+	if err != nil {
+		return err
+	}
+
+	return s.Serve(l)
+}
+
+// Stop the telnet server. This stops listening for new connections, but does
+// not affect any active connections already opened.
+func (s *Server) Stop() {
+	if s.quitting {
+		return
+	}
+	s.quitting = true
+	s.listener.Close()
+}

server_test.go

@@ -0,0 +1,44 @@
+package telnet_test
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/aprice/telnet"
+)
+
+func TestServer_ListenAndServe(t *testing.T) {
+	wg := new(sync.WaitGroup)
+	s := telnet.NewServer("127.0.0.1:0", telnet.HandleFunc(func(c *telnet.Connection) {
+		wg.Add(1)
+		_, err := c.Write([]byte("Hello!"))
+		if err != nil {
+			t.Error(err)
+		}
+		err = c.Close()
+		if err != nil {
+			t.Error(err)
+		}
+		wg.Done()
+	}))
+	wg.Add(1)
+	go func() {
+		err := s.ListenAndServe()
+		if err != nil {
+			t.Error(err)
+		}
+		wg.Done()
+	}()
+	time.Sleep(time.Millisecond)
+	client, err := telnet.Dial(s.Address)
+	if err != nil {
+		t.Error(err)
+	}
+	err = client.Close()
+	if err != nil {
+		t.Error(err)
+	}
+	s.Stop()
+	wg.Wait()
+}