starting to clean up code

README.md

@@ -0,0 +1,29 @@
+# rttymodem
+This is a backwards modem to connect a teletype to the internet via a terminal unit and your computer's audio interface. The modem supports a subset of the Hayes modem command set, and is backwards because the DTE is on the modulated side of the modem. The DCE side of the modem supports communication over over raw TCP sockets.
+
+## S Registers
+
+### 0 - Auto Answer
+Default: 0 (Disabled)
+
+When set to 1, the modem allows inbound TCP connections
+
+### 2 - Escape Code
+Default: ?
+The character 
+
+### 91 - Modulator Enable
+Default: 1 (Enabled)
+
+When set to 1, the modulator audio output is enabled
+
+### 92 - Turnaround Delay
+Default: 0
+
+This only applies to AT commands entered at the modem interface; this is the delay in milliseconds between submitting a command, and when the response is sent.
+
+### 93 - Un-shift On Space
+Default: Enabled
+
+### 94 - TCP Port
+Default: 3333

main.go

@@ -4,16 +4,12 @@ import (
 	"fmt"
 
 	"bufio"
-	"bytes"
 	"github.com/gordonklaus/portaudio"
 	"github.com/naleek/gortty"
 	"io"
-	"net"
 	"regexp"
 	"strings"
-	"unicode/utf8"
 	"time"
-	"os"
 	"strconv"
 )
 
@@ -56,7 +52,6 @@ func main() {
 	if !useStdio {
 		// Set up modulator pipeline
 		ttyToEncoder := make(chan rune, 100)
-		m.ttyWriter = NewModemWriter(ttyToEncoder)
 		encoderToModulator := make(chan byte)
 		m.encoder = gortty.NewEncoder(ttyToEncoder, encoderToModulator, charset)
 		m.modulator = gortty.NewModulator(rttySettings, encoderToModulator, modulatorToAudio)
@@ -67,10 +62,6 @@ func main() {
 		m.demodulator = gortty.NewDemodulator(rttySettings, audioToDemodulator, demodulatorToDecoder)
 		decoderToTTY := make(chan rune)
 		m.decoder = gortty.NewDecoder(demodulatorToDecoder, decoderToTTY, charset)
-		m.ttyReader = NewModemReader(decoderToTTY)
-	} else {
-		m.ttyReader = os.Stdin
-		m.ttyWriter = os.Stdout
 	}
 		
 	go m.cli()
@@ -103,54 +94,22 @@ func main() {
 	
 }
 
-type ModemReader struct {
-	input chan rune
-}
-
-func NewModemReader(c chan rune) *ModemReader {
-	m := &ModemReader{}
-	m.input = c
-	return m
-}
-
-func (m *ModemReader) Read(p []byte) (n int, err error) {
-	r := <-m.input
-
-	fmt.Print(string(r))
-
-	l := utf8.EncodeRune(p, r)
-	return l, nil
-}
-
-func (m *ModemReader) Add(b rune) {
-	m.input <- b
-}
-
-type ModemWriter struct {
-	output chan rune
-}
-
-func NewModemWriter(c chan rune) *ModemWriter {
-	m := &ModemWriter{}
-	m.output = c
-	return m
-}
-
-func (m *ModemWriter) Write(p []byte) (n int, err error) {
-
-	runes := bytes.Runes(p)
-
-	fmt.Print(string(runes))
-	
-	for _, r := range runes {
-		m.output <- r
-	}
-	return len(p), nil
-}
+//type ModemReader struct {
+//	input chan rune
+//}
+//
+//func NewModemReader(c chan rune) *ModemReader {
+//	m := &ModemReader{}
+//	m.input = c
+//	return m
+//}
+//
+//func (m *ModemReader) Read(p []byte) (n int, err error) {
+//	r := <-m.input
+//	l := utf8.EncodeRune(p, r)
+//	return l, nil
+//}
 
-func (m *ModemWriter) Get() rune {
-	return <-m.output
-}
 
 type modem struct {
 	ttyReader io.Reader
@@ -288,7 +247,7 @@ func (m *modem) cli() {
 	}
 	
 	localEcho := false
-	ttyBufferedReader := bufio.NewReader(m.ttyReader)
+	ttyBufferedReader := bufio.NewReader(m.decoder)
 	
 	var netConn *NetConn
 	
@@ -333,23 +292,23 @@ func (m *modem) cli() {
 			parameter = params[5]
 		}
 
-		//fmt.Fprintf(m.ttyWriter, "command: '%s' register: '%s' query: '%s' value: '%s' parameter: '%s'\n", command, register, registerQuery, value, parameter)
+		//fmt.Fprintf(m.encoder, "command: '%s' register: '%s' query: '%s' value: '%s' parameter: '%s'\n", command, register, registerQuery, value, parameter)
 		switch command {
 		case "?":
-			fmt.Fprintf(m.ttyWriter, "Setting Registers\n")
+			fmt.Fprintf(m.encoder, "Setting Registers\n")
 			for s, conf := range settings {
-				fmt.Fprintf(m.ttyWriter, "%s: %s (current value: %s)\n", s, conf.help, conf.f(registerGet, ""))
+				fmt.Fprintf(m.encoder, "%s: %s (current value: %s)\n", s, conf.help, conf.f(registerGet, ""))
 			}
 		case "O": // online
 			if !netConn.Connected() {
-				fmt.Fprintln(m.ttyWriter, "ERROR No active session")
+				fmt.Fprintln(m.encoder, "ERROR No active session")
 				break
 			}
-			fmt.Fprintln(m.ttyWriter, "OK")
-			dataMode(netConn, ttyBufferedReader, m.ttyWriter, escapeRune)
+			fmt.Fprintln(m.encoder, "OK")
+			dataMode(netConn, ttyBufferedReader, m.encoder, escapeRune)
 		case "D": // dial
 			if netConn.Connected() {
-				fmt.Fprintln(m.ttyWriter, "ERROR Session in progress")
+				fmt.Fprintln(m.encoder, "ERROR Session in progress")
 				break
 			}
 			addr := strings.TrimSpace(parameter)
@@ -357,30 +316,30 @@ func (m *modem) cli() {
 			var err error
 			netConn, err = NewNetConn(addr)
 			if err != nil {
-				fmt.Fprintln(m.ttyWriter, "ERROR", err)
+				fmt.Fprintln(m.encoder, "ERROR", err)
 				break
 			} else {
-				fmt.Fprintln(m.ttyWriter, "CONNECTED")
-				dataMode(netConn, ttyBufferedReader, m.ttyWriter, escapeRune)
+				fmt.Fprintln(m.encoder, "CONNECTED")
+				dataMode(netConn, ttyBufferedReader, m.encoder, escapeRune)
 			}
 		case "H": // hangup
 			if !netConn.Connected() {
-				fmt.Fprintln(m.ttyWriter, "ERROR No active session")
+				fmt.Fprintln(m.encoder, "ERROR No active session")
 				break
 			}
 			netConn.Hangup()
-			fmt.Fprintln(m.ttyWriter, "OK")
+			fmt.Fprintln(m.encoder, "OK")
 		case "E": // local echo
 			localEcho = (register == "1")
-			fmt.Fprintln(m.ttyWriter, "local echo", localEcho)
+			fmt.Fprintln(m.encoder, "local echo", localEcho)
 		case "S": // local echo
 			if conf, ok := settings[register]; ok {
 				if registerQuery == "?" {
-					fmt.Fprintln(m.ttyWriter, conf.f(registerGet, ""))
+					fmt.Fprintln(m.encoder, conf.f(registerGet, ""))
 				} else if value != "" {
-					fmt.Fprintln(m.ttyWriter, conf.f(registerSet, value))
+					fmt.Fprintln(m.encoder, conf.f(registerSet, value))
 				} else {
-					fmt.Fprintln(m.ttyWriter, "ERROR")
+					fmt.Fprintln(m.encoder, "ERROR")
 				}
 			}
 		}
@@ -474,113 +433,6 @@ pipeLoop:
 
 
 
-type NetConn struct {
-	netReader *bufio.Reader
-	conn net.Conn
-	netReadChan chan rune
-	hangup chan struct{}
-	paused  bool
-	connected bool
-}
-
-func NewNetConn(addr string) (*NetConn, error) {
-	c := &NetConn{}
-	var err error
-	c.conn, err = net.Dial("tcp", addr)
-	if err != nil {
-		return nil, err
-	}
-	c.connected = true
-
-	c.netReader = bufio.NewReader(c.conn)
-	
-	c.netReadChan = make(chan rune)
-	c.hangup = make(chan struct{})
-	c.paused = false
-	
-	go func() {
-		for {
-			r, l, err := c.netReader.ReadRune()
-			if err != nil && err != io.EOF {
-				c.cleanup()
-				return
-			}
-			if c.paused || l == 0 {
-				select {
-				case <- c.hangup:
-					c.cleanup()
-					return
-				default: // discard
-				}
-			} else {
-				select {
-				case c.netReadChan <- r:
-				case <- c.hangup:
-					c.cleanup()
-					return
-				}
-			}
-		}
-		
-	}()
-	
-	
-	return c, nil
-}
-
-func (c *NetConn) Write(r rune) error {
-	if c == nil {
-		return fmt.Errorf("NetConn not initialized")
-	}
-	_, err := c.conn.Write([]byte(string(r)))
-	if err != nil {	
-		close(c.hangup)
-	}
-	return err
-}
-
-func (c *NetConn) Hangup() {
-	if c == nil {
-		return
-	}
-	c.conn.Close()
-	close(c.hangup)
-}
-
-func (c *NetConn) cleanup() {
-	close(c.netReadChan)
-	c.connected = false 
-}
-
-func (c *NetConn) Pause() {
-	if c == nil {
-		return
-	}
-	c.paused = true
-}
-
-func (c *NetConn) Resume() {
-	if c == nil {
-		return
-	}
-	c.paused = false
-}
-
-func (c *NetConn) OutputChannel() chan rune {
-	if c == nil {
-		return nil
-	}
-	return c.netReadChan
-}
-
-func (c *NetConn) Connected() bool {
-	if c == nil {
-		return false
-	}
-	return c.connected
-}
-
-
 
 
 

netconn.go

@@ -0,0 +1,115 @@
+package main
+
+import (
+	"bufio"
+	"net"
+	"io"
+	"fmt"
+)
+
+type NetConn struct {
+	netReader *bufio.Reader
+	conn net.Conn
+	netReadChan chan rune
+	hangup chan struct{}
+	paused  bool
+	connected bool
+}
+
+func NewNetConn(addr string) (*NetConn, error) {
+	c := &NetConn{}
+	var err error
+	c.conn, err = net.Dial("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+	c.connected = true
+
+	c.netReader = bufio.NewReader(c.conn)
+	
+	c.netReadChan = make(chan rune)
+	c.hangup = make(chan struct{})
+	c.paused = false
+	
+	go func() {
+		for {
+			r, l, err := c.netReader.ReadRune()
+			if err != nil && err != io.EOF {
+				c.cleanup()
+				return
+			}
+			if c.paused || l == 0 {
+				select {
+				case <- c.hangup:
+					c.cleanup()
+					return
+				default: // discard
+				}
+			} else {
+				select {
+				case c.netReadChan <- r:
+				case <- c.hangup:
+					c.cleanup()
+					return
+				}
+			}
+		}
+		
+	}()
+	
+	
+	return c, nil
+}
+
+func (c *NetConn) Write(r rune) error {
+	if c == nil {
+		return fmt.Errorf("NetConn not initialized")
+	}
+	_, err := c.conn.Write([]byte(string(r)))
+	if err != nil {	
+		close(c.hangup)
+	}
+	return err
+}
+
+func (c *NetConn) Hangup() {
+	if c == nil {
+		return
+	}
+	c.conn.Close()
+	close(c.hangup)
+}
+
+func (c *NetConn) cleanup() {
+	close(c.netReadChan)
+	c.connected = false 
+}
+
+func (c *NetConn) Pause() {
+	if c == nil {
+		return
+	}
+	c.paused = true
+}
+
+func (c *NetConn) Resume() {
+	if c == nil {
+		return
+	}
+	c.paused = false
+}
+
+func (c *NetConn) OutputChannel() chan rune {
+	if c == nil {
+		return nil
+	}
+	return c.netReadChan
+}
+
+func (c *NetConn) Connected() bool {
+	if c == nil {
+		return false
+	}
+	return c.connected
+}
+