more cleanup

main.go

@@ -1,444 +1,101 @@
 package main
 
 import (
+	"context"
+	"flag"
 	"fmt"
-
-	"bufio"
-	"github.com/gordonklaus/portaudio"
+	"github.com/BurntSushi/toml"
 	"github.com/naleek/gortty"
-	"io"
-	"regexp"
-	"strings"
-	"time"
+	"log"
+	"os"
 	"strconv"
 )
 
+const (
+	verMajor = 0
+	verMinor = 1
+	verPatch = 0
+)
+
+type config struct {
+	Baud           float64           `toml:"baud"`
+	StopBits       float64           `toml:"stopbits"`
+	DataBits       int               `toml:"databits"`
+	SampleRate     int               `toml:"samplerate"`
+	MarkFrequency  int               `toml:"markfrequency"`
+	SpaceFrequency int               `toml:"spacefrequency"`
+	LocalEcho      bool              `toml:"localecho"`
+	CodeSet        string            `toml:"codeset"`
+	Registers      map[string]string `toml:"registers"`
+}
 
 func main() {
 
-	m := &modem{}
-	
-	rttySettings := &gortty.ModemSettings{
-		Baud:       45,
-		StopBits:   2,
-		DataBits:   5,
-		SampleRate: 8000,
-		OneFreq:    2125,
-		ZeroFreq:   2295,
-	}
+	var configFile string
 
-	charset := gortty.LoadCharset(&gortty.USTTY)
+	flag.StringVar(&configFile, "c", "rttymodem.toml", "Configuration file path")
 
-	in := make([]int16, 64)
-	out := make([]int16, 64)
-	var stream *portaudio.Stream
-	
-	useStdio := false
-	
-	if !useStdio {
-		// Set up audio with system default input and output
-		portaudio.Initialize()
-		defer portaudio.Terminate()
-		var err error
-		stream, err = portaudio.OpenDefaultStream(1, 1, float64(rttySettings.SampleRate), len(in), in, out)
-		if err != nil {
-			panic(err)
-		}
-		defer stream.Close()
-	}
-	modulatorToAudio := make(chan int16)
-	audioToDemodulator := make(chan int16)
+	showHelp := flag.Bool("h", false, "Show usage and exit")
+	showVersion := flag.Bool("v", false, "Show version and exit")
 
-	if !useStdio {
-		// Set up modulator pipeline
-		ttyToEncoder := make(chan rune, 100)
-		encoderToModulator := make(chan byte)
-		m.encoder = gortty.NewEncoder(ttyToEncoder, encoderToModulator, charset)
-		m.modulator = gortty.NewModulator(rttySettings, encoderToModulator, modulatorToAudio)
-		m.modulator.SetIdleDelay(1000)
-		
-		// Set up demodulator pipeline	
-		demodulatorToDecoder := make(chan byte)
-		m.demodulator = gortty.NewDemodulator(rttySettings, audioToDemodulator, demodulatorToDecoder)
-		decoderToTTY := make(chan rune)
-		m.decoder = gortty.NewDecoder(demodulatorToDecoder, decoderToTTY, charset)
-	}
-		
-	go m.cli()
+	flag.Parse()
 
-	if !useStdio {
-		// start audio
-		stream.Start()
-		defer stream.Stop()
-		// Run audio output in goroutine
-		go func() {
-			l := 0
-			for v := range modulatorToAudio {
-				out[l] = v
-				l++
-				if l == 64 {
-					l = 0
-					stream.Write()
-				}
-			}
-		}()
-	
-		// Run audio input 
-		for {
-			stream.Read()
-			for i := range in {
-				audioToDemodulator <- in[i]
-			}
-		}
+	if *showHelp {
+		flag.PrintDefaults()
+		os.Exit(0)
 	}
-	
-}
-
-//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
-//}
 
-
-type modem struct {
-	ttyReader io.Reader
-	ttyWriter io.Writer
-	modulator *gortty.Modulator
-	demodulator *gortty.Demodulator
-	encoder *gortty.Encoder
-	decoder *gortty.Decoder
-}
-
-func (m *modem) modulatorCallback(event int, data interface{}) {
-	switch event {
-	case gortty.EventActive:
-		fmt.Println("EventActive")
-		m.demodulator.Inhibit(true)
-	case gortty.EventIdle:
-		fmt.Println("EventIdle")
-		m.demodulator.Inhibit(false)
+	if *showVersion {
+		fmt.Printf("%d.%d.%d\n", verMajor, verMinor, verPatch)
+		os.Exit(0)
 	}
-}
 
-type configFunction func(action int, value string) string
+	log.Printf("starting up with config from %s")
 
-type configRegister struct {
-	help		 string
-	f configFunction
-}
-
-const (
-	registerGet = iota
-	registerSet
-)
-
-func (m *modem) cli() {
+	conf := &config{}
 
-	fmt.Println("RTTY TCP Modem 1.0")
-
-	autoAnswer := false
-	escapeRune := '?'
-	modulatorOn := true
-	turnaroundDelay := 0
-	usos := false
-	
-	settings := map[string]configRegister{
-		"0": {
-			help: "auto-answer enable",
-			f: func(action int, value string) string {
-				switch action {
-				case registerGet:
-					if autoAnswer {
-						return "1"
-					} else {
-						return "0"
-					}
-				case registerSet:
-					autoAnswer = (value == "1")
-					return "OK"
-				}
-				return ""
-			},
-		},
-		"2": {
-			help: "escape character",
-			f: func(action int, value string) string {
-				switch action {
-				case registerGet:
-					return string(escapeRune)
-				case registerSet:
-					runes := []rune(value)
-					escapeRune = runes[0]
-					return "OK"
-				}
-				return ""
-			},
-		},
-		"3": {
-			help: "modulator enable",
-			f: func(action int, value string) string {
-				switch action {
-				case registerGet:
-					if modulatorOn {
-						return "1"
-					} else {
-						return "0"
-					}
-				case registerSet:
-					modulatorOn = (value == "1")
-					if m.modulator != nil {
-						if modulatorOn {
-							m.modulator.SetAmplitude(16384)
-						} else {	
-							m.modulator.SetAmplitude(0)
-						}
-					}
-					return "OK"
-				}
-				return ""
-			},
-		},
-		"4": {
-			help: "turnaround delay",
-			f: func(action int, value string) string {
-				switch action {
-				case registerGet:
-					return fmt.Sprintln(turnaroundDelay)
-				case registerSet:
-					if d, err := strconv.Atoi(value); err == nil {
-						turnaroundDelay = d
-						return "OK"
-					} else {
-						return "ERROR"
-					}
-				}
-				return ""
-			},
-		},
-		"5": {
-			help: "unshift on space",
-			f: func(action int, value string) string {
-				switch action {
-				case registerGet:
-					if usos {
-						return "1"
-					} else {
-						return "0"
-					}
-				case registerSet:
-					usos = (value == "1")
-					m.decoder.UnshiftOnSpace(usos)
-					return "OK"
-				}
-				return ""
-			},
-		},
-	}
-	
-	localEcho := false
-	ttyBufferedReader := bufio.NewReader(m.decoder)
-	
-	var netConn *NetConn
-	
-	if m.modulator != nil {
-		m.modulator.SetCallback(m.modulatorCallback)
+	if _, err := toml.DecodeFile(configFile, &conf); err != nil {
+		log.Fatal(err)
 	}
-	
-
-	for { 
-
-		s, _ := ttyBufferedReader.ReadString('\n')
-
-		//fmt.Println(s) 
-		s = strings.ToUpper(s)
-		regex, _ := regexp.Compile(`^AT([SHOED?])([0-9])?(\?)?(?:[=|\:]([\S]*))?(?: (.*))?`)
-
-		params := regex.FindStringSubmatch(s)
-
-		if params == nil {
-			continue
-		}
-
-		command := params[1]
-
-		var register string
-		if len(params) > 2 {
-			register = params[2]
-		}
 
-		var registerQuery string
-		if len(params) > 3 {
-			registerQuery = params[3]
-		}
-
-		var value string
-		if len(params) > 4 {
-			value = params[4]
-		}
-
-		var parameter string
-		if len(params) > 5 {
-			parameter = params[5]
-		}
-
-		//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.encoder, "Setting Registers\n")
-			for s, conf := range settings {
-				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.encoder, "ERROR No active session")
-				break
-			}
-			fmt.Fprintln(m.encoder, "OK")
-			dataMode(netConn, ttyBufferedReader, m.encoder, escapeRune)
-		case "D": // dial
-			if netConn.Connected() {
-				fmt.Fprintln(m.encoder, "ERROR Session in progress")
-				break
-			}
-			addr := strings.TrimSpace(parameter)
-			
-			var err error
-			netConn, err = NewNetConn(addr)
-			if err != nil {
-				fmt.Fprintln(m.encoder, "ERROR", err)
-				break
-			} else {
-				fmt.Fprintln(m.encoder, "CONNECTED")
-				dataMode(netConn, ttyBufferedReader, m.encoder, escapeRune)
-			}
-		case "H": // hangup
-			if !netConn.Connected() {
-				fmt.Fprintln(m.encoder, "ERROR No active session")
-				break
-			}
-			netConn.Hangup()
-			fmt.Fprintln(m.encoder, "OK")
-		case "E": // local echo
-			localEcho = (register == "1")
-			fmt.Fprintln(m.encoder, "local echo", localEcho)
-		case "S": // local echo
-			if conf, ok := settings[register]; ok {
-				if registerQuery == "?" {
-					fmt.Fprintln(m.encoder, conf.f(registerGet, ""))
-				} else if value != "" {
-					fmt.Fprintln(m.encoder, conf.f(registerSet, value))
-				} else {
-					fmt.Fprintln(m.encoder, "ERROR")
-				}
-			}
-		}
+	s := &gortty.ModemSettings{
+		Baud:       conf.Baud,
+		StopBits:   conf.StopBits,
+		DataBits:   conf.DataBits,
+		SampleRate: conf.SampleRate,
+		OneFreq:    conf.MarkFrequency,
+		ZeroFreq:   conf.SpaceFrequency,
 	}
 
-}
-
+	if conf.CodeSet == "" {
+		conf.CodeSet = "USTTY"
+	}
 
+	c, err := gortty.LoadCodeSet(conf.CodeSet)
+	if err != nil {
+		log.Fatal(err)
+	}
 
-func dataMode(netConn *NetConn, ttyBufferedReader *bufio.Reader, ttyWriter io.Writer, escapeRune rune) {
-	
-	ttyCancelReader := make(chan struct{})
-	ttyReadChan := make(chan rune)
-	ttyReadPending := make(chan struct{})
-	
-	var t *time.Timer
-	escapeRunes := 0
+	ctx, cancel := context.WithCancel(context.Background())
 
+	m, err := NewModem(ctx, s, c)
+	if err != nil {
+		log.Fatal(err)
+	}
 
-	go func() {
-		for {
-			r, l, err := ttyBufferedReader.ReadRune()
-			if err != nil && err != io.EOF {
-				return
-			}
-			if l > 0 {
-				select {
-				case <-ttyCancelReader:
-					ttyBufferedReader.UnreadRune() // oops this wasn't ours. let's put it back.
-					close(ttyReadPending)
-					return
-				default:
-					ttyReadChan <- r
-				}
-			}
-		}
-	}()
-	
-	netReadChan := netConn.OutputChannel()
-	netConn.Resume()
-pipeLoop:	
-	for {
-		var r rune	
-		if t == nil {
-			select {
-				case r = <-ttyReadChan:
-				case q := <-netReadChan:
-					ttyWriter.Write([]byte(string(q)))
-					continue pipeLoop
-			}
-		} else {
-			select {
-				case r = <-ttyReadChan:
-				case q := <-netReadChan:
-					ttyWriter.Write([]byte(string(q)))
-					continue pipeLoop
-				case <-t.C:
-					fmt.Fprintln(ttyWriter, "\nOK")
-					close(ttyCancelReader)
-					netConn.Pause()
-					break pipeLoop
+	m.SetLocalEcho(conf.LocalEcho)
 
-			}
-		}
-		if r == escapeRune && escapeRunes < 3 {
-			escapeRunes++
-		} else {
-			if t != nil {
-				t.Stop()
-			}
-			escapeRunes = 0
-		}
-		if escapeRunes == 3 {
-			t = time.NewTimer(1*time.Second)
-		}
-		err := netConn.Write(r)
+	for i, r := range conf.Registers {
+		n, err := strconv.Atoi(i)
 		if err != nil {
-			fmt.Fprintln(ttyWriter, "NO CARRIER")
-			close(ttyCancelReader)
-			break pipeLoop
+			continue
 		}
+		m.SetRegister(n, r)
 	}
-	<- ttyReadPending
-	
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
+	defer m.Close()
 
+	m.run()
 
+	cancel()
+}

modem.go

@@ -0,0 +1,421 @@
+package main
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gordonklaus/portaudio"
+	"github.com/naleek/gortty"
+)
+
+type Modem struct {
+	ttyReader       io.Reader
+	ttyWriter       io.Writer
+	modulator       *gortty.Modulator
+	demodulator     *gortty.Demodulator
+	encoder         *gortty.Encoder
+	decoder         *gortty.Decoder
+	stream          *portaudio.Stream
+	registers       map[int]configRegister
+	autoAnswer      bool
+	escapeRune      rune
+	modulatorOn     bool
+	turnaroundDelay int
+	usos            bool
+	localEcho       bool
+}
+
+func (m *Modem) Close() {
+	m.stream.Close()
+	portaudio.Terminate()
+}
+
+func (m *Modem) SetLocalEcho(e bool) {
+	m.localEcho = e
+}
+
+func (m *Modem) GetRegister(index int) (string, bool) {
+	if r, ok := m.registers[index]; ok {
+		return r.f(registerGet, ""), true
+	}
+	return "", false
+}
+
+func (m *Modem) SetRegister(index int, value string) bool {
+	if r, ok := m.registers[index]; ok {
+		r.f(registerSet, value)
+		return true
+	} else {
+		return false
+	}
+}
+
+func NewModem(ctx context.Context, rttySettings *gortty.ModemSettings, charset *gortty.CodeSet) (*Modem, error) {
+	m := &Modem{}
+
+	m.registers = map[int]configRegister{
+		0: {
+			help: "auto-answer enable",
+			f: func(action int, value string) string {
+				switch action {
+				case registerGet:
+					if m.autoAnswer {
+						return "1"
+					} else {
+						return "0"
+					}
+				case registerSet:
+					m.autoAnswer = (value == "1")
+					return "OK"
+				}
+				return ""
+			},
+		},
+		2: {
+			help: "escape character",
+			f: func(action int, value string) string {
+				switch action {
+				case registerGet:
+					return string(m.escapeRune)
+				case registerSet:
+					runes := []rune(value)
+					m.escapeRune = runes[0]
+					return "OK"
+				}
+				return ""
+			},
+		},
+		101: {
+			help: "modulator enable",
+			f: func(action int, value string) string {
+				switch action {
+				case registerGet:
+					if m.modulatorOn {
+						return "1"
+					} else {
+						return "0"
+					}
+				case registerSet:
+					m.modulatorOn = (value == "1")
+					if m.modulator != nil {
+						if m.modulatorOn {
+							m.modulator.SetAmplitude(16384)
+						} else {
+							m.modulator.SetAmplitude(0)
+						}
+					}
+					return "OK"
+				}
+				return ""
+			},
+		},
+		102: {
+			help: "turnaround delay",
+			f: func(action int, value string) string {
+				switch action {
+				case registerGet:
+					return fmt.Sprintln(m.turnaroundDelay)
+				case registerSet:
+					if d, err := strconv.Atoi(value); err == nil {
+						m.turnaroundDelay = d
+						return "OK"
+					} else {
+						return "ERROR"
+					}
+				}
+				return ""
+			},
+		},
+		103: {
+			help: "unshift on space",
+			f: func(action int, value string) string {
+				switch action {
+				case registerGet:
+					if m.usos {
+						return "1"
+					} else {
+						return "0"
+					}
+				case registerSet:
+					m.usos = (value == "1")
+					m.decoder.UnshiftOnSpace(m.usos)
+					return "OK"
+				}
+				return ""
+			},
+		},
+	}
+
+	m.autoAnswer = false
+	m.escapeRune = '?'
+	m.modulatorOn = true
+	m.turnaroundDelay = 0
+	m.usos = false
+
+	in := make([]int16, 64)
+	out := make([]int16, 64)
+
+	// Set up audio with system default input and output
+	portaudio.Initialize()
+	var err error
+	m.stream, err = portaudio.OpenDefaultStream(1, 1, float64(rttySettings.SampleRate), len(in), in, out)
+	if err != nil {
+		panic(err)
+	}
+
+	modulatorToAudio := make(chan int16)
+	audioToDemodulator := make(chan int16)
+
+	// Set up modulator pipeline
+	encoderToModulator := make(chan byte)
+	m.encoder = gortty.NewEncoder(ctx, nil, encoderToModulator, charset)
+	m.modulator = gortty.NewModulator(ctx, rttySettings, encoderToModulator, modulatorToAudio)
+	m.modulator.SetIdleDelay(1000)
+
+	// Set up demodulator pipeline
+	demodulatorToDecoder := make(chan byte)
+	m.demodulator = gortty.NewDemodulator(ctx, rttySettings, audioToDemodulator, demodulatorToDecoder)
+	m.decoder = gortty.NewDecoder(ctx, demodulatorToDecoder, nil, charset)
+
+	// start audio
+	m.stream.Start()
+
+	// Audio output
+	go func() {
+		l := 0
+		for v := range modulatorToAudio {
+			out[l] = v
+			l++
+			if l == 64 {
+				l = 0
+				m.stream.Write()
+			}
+		}
+	}()
+
+	// Audio input
+	go func() {
+		for {
+			m.stream.Read()
+			for i := range in {
+				audioToDemodulator <- in[i]
+			}
+		}
+	}()
+
+	return m, nil
+}
+
+func (m *Modem) modulatorCallback(event int, data interface{}) {
+	switch event {
+	case gortty.EventActive:
+		fmt.Println("EventActive")
+		m.demodulator.Inhibit(true)
+	case gortty.EventIdle:
+		fmt.Println("EventIdle")
+		m.demodulator.Inhibit(false)
+	}
+}
+
+type configFunction func(action int, value string) string
+
+type configRegister struct {
+	help string
+	f    configFunction
+}
+
+const (
+	registerGet = iota
+	registerSet
+)
+
+func (m *Modem) run() {
+
+	ttyBufferedReader := bufio.NewReader(m.decoder)
+
+	var netConn *NetConn
+
+	if m.modulator != nil {
+		m.modulator.SetCallback(m.modulatorCallback)
+	}
+
+	for {
+
+		s, _ := ttyBufferedReader.ReadString('\n')
+
+		//fmt.Println(s)
+		s = strings.ToUpper(s)
+		regex, _ := regexp.Compile(`^AT([SHOED?])([0-9])?(\?)?(?:[=|\:]([\S]*))?(?: (.*))?`)
+
+		params := regex.FindStringSubmatch(s)
+
+		if params == nil {
+			continue
+		}
+
+		command := params[1]
+
+		var register string
+		if len(params) > 2 {
+			register = params[2]
+		}
+
+		var registerQuery string
+		if len(params) > 3 {
+			registerQuery = params[3]
+		}
+
+		var value string
+		if len(params) > 4 {
+			value = params[4]
+		}
+
+		var parameter string
+		if len(params) > 5 {
+			parameter = params[5]
+		}
+
+		//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.encoder, "Setting Registers\n")
+			for s, conf := range m.registers {
+				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.encoder, "ERROR No active session")
+				break
+			}
+			fmt.Fprintln(m.encoder, "OK")
+			dataMode(netConn, ttyBufferedReader, m.encoder, m.escapeRune)
+		case "D": // dial
+			if netConn.Connected() {
+				fmt.Fprintln(m.encoder, "ERROR Session in progress")
+				break
+			}
+			addr := strings.TrimSpace(parameter)
+
+			var err error
+			netConn, err = NewNetConn(addr)
+			if err != nil {
+				fmt.Fprintln(m.encoder, "ERROR", err)
+				break
+			} else {
+				fmt.Fprintln(m.encoder, "CONNECTED")
+				dataMode(netConn, ttyBufferedReader, m.encoder, m.escapeRune)
+			}
+		case "H": // hangup
+			if !netConn.Connected() {
+				fmt.Fprintln(m.encoder, "ERROR No active session")
+				break
+			}
+			netConn.Hangup()
+			fmt.Fprintln(m.encoder, "OK")
+		case "E": // local echo
+			m.localEcho = (register == "1")
+			fmt.Fprintln(m.encoder, "local echo", m.localEcho)
+		case "S": // register
+			r, _ := strconv.Atoi(register)
+			if registerQuery == "?" { // get
+				if v, ok := m.GetRegister(r); ok {
+					fmt.Fprintln(m.encoder, v)
+				} else {
+					fmt.Fprintln(m.encoder, "ERROR")
+				}
+			} else if value != "" { //set
+				if m.SetRegister(r, value) {
+					fmt.Fprintln(m.encoder, "OK")
+				} else {
+					fmt.Fprintln(m.encoder, "ERROR")
+				}
+			} else {
+				fmt.Fprintln(m.encoder, "ERROR")
+			}
+
+		}
+	}
+
+}
+
+func dataMode(netConn *NetConn, ttyBufferedReader *bufio.Reader, ttyWriter io.Writer, escapeRune rune) {
+
+	ttyCancelReader := make(chan struct{})
+	ttyReadChan := make(chan rune)
+	ttyReadPending := make(chan struct{})
+
+	var t *time.Timer
+	escapeRunes := 0
+
+	go func() {
+		for {
+			r, l, err := ttyBufferedReader.ReadRune()
+			if err != nil && err != io.EOF {
+				return
+			}
+			if l > 0 {
+				select {
+				case <-ttyCancelReader:
+					ttyBufferedReader.UnreadRune() // oops this wasn't ours. let's put it back.
+					close(ttyReadPending)
+					return
+				default:
+					ttyReadChan <- r
+				}
+			}
+		}
+	}()
+
+	netReadChan := netConn.OutputChannel()
+	netConn.Resume()
+pipeLoop:
+	for {
+		var r rune
+		if t == nil {
+			select {
+			case r = <-ttyReadChan:
+			case q := <-netReadChan:
+				ttyWriter.Write([]byte(string(q)))
+				continue pipeLoop
+			}
+		} else {
+			select {
+			case r = <-ttyReadChan:
+			case q := <-netReadChan:
+				ttyWriter.Write([]byte(string(q)))
+				continue pipeLoop
+			case <-t.C:
+				fmt.Fprintln(ttyWriter, "\nOK")
+				close(ttyCancelReader)
+				netConn.Pause()
+				break pipeLoop
+
+			}
+		}
+		if r == escapeRune && escapeRunes < 3 {
+			escapeRunes++
+		} else {
+			if t != nil {
+				t.Stop()
+			}
+			escapeRunes = 0
+		}
+		if escapeRunes == 3 {
+			t = time.NewTimer(1 * time.Second)
+		}
+		err := netConn.Write(r)
+		if err != nil {
+			fmt.Fprintln(ttyWriter, "NO CARRIER")
+			close(ttyCancelReader)
+			break pipeLoop
+		}
+	}
+	<-ttyReadPending
+
+}

netconn.go

@@ -2,18 +2,18 @@ package main
 
 import (
 	"bufio"
-	"net"
-	"io"
 	"fmt"
+	"io"
+	"net"
 )
 
 type NetConn struct {
-	netReader *bufio.Reader
-	conn net.Conn
+	netReader   *bufio.Reader
+	conn        net.Conn
 	netReadChan chan rune
-	hangup chan struct{}
-	paused  bool
-	connected bool
+	hangup      chan struct{}
+	paused      bool
+	connected   bool
 }
 
 func NewNetConn(addr string) (*NetConn, error) {
@@ -26,11 +26,11 @@ func NewNetConn(addr string) (*NetConn, error) {
 	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()
@@ -40,7 +40,7 @@ func NewNetConn(addr string) (*NetConn, error) {
 			}
 			if c.paused || l == 0 {
 				select {
-				case <- c.hangup:
+				case <-c.hangup:
 					c.cleanup()
 					return
 				default: // discard
@@ -48,16 +48,15 @@ func NewNetConn(addr string) (*NetConn, error) {
 			} else {
 				select {
 				case c.netReadChan <- r:
-				case <- c.hangup:
+				case <-c.hangup:
 					c.cleanup()
 					return
 				}
 			}
 		}
-		
+
 	}()
-	
-	
+
 	return c, nil
 }
 
@@ -66,7 +65,7 @@ func (c *NetConn) Write(r rune) error {
 		return fmt.Errorf("NetConn not initialized")
 	}
 	_, err := c.conn.Write([]byte(string(r)))
-	if err != nil {	
+	if err != nil {
 		close(c.hangup)
 	}
 	return err
@@ -82,7 +81,7 @@ func (c *NetConn) Hangup() {
 
 func (c *NetConn) cleanup() {
 	close(c.netReadChan)
-	c.connected = false 
+	c.connected = false
 }
 
 func (c *NetConn) Pause() {
@@ -112,4 +111,3 @@ func (c *NetConn) Connected() bool {
 	}
 	return c.connected
 }
-

rttymodem.toml

@@ -0,0 +1,20 @@
+
+baud = 45.45
+stopbits = 1.42
+databits = 5
+samplerate = 8000
+markfrequency = 2125
+spacefrequency = 2295
+
+codeset = "USTTY"
+
+localecho = false
+
+
+[registers]
+0   = "0"   	# auto-answer
+2   = "?"		# escape character
+101 = "1"		# modulator enable
+102 = "0"		# turnaround delay
+103 = "0"		# unshift on space
+104 = ":3333"	# listen address