Initial commit

main.go

@@ -0,0 +1,592 @@
+package main
+
+import (
+	"fmt"
+
+	"bufio"
+	"bytes"
+	"github.com/gordonklaus/portaudio"
+	"github.com/naleek/gortty"
+	"io"
+	"net"
+	"regexp"
+	"strings"
+	"unicode/utf8"
+	"time"
+	"os"
+	"strconv"
+)
+
+
+func main() {
+
+	m := &modem{}
+	
+	rttySettings := &gortty.ModemSettings{
+		Baud:       45,
+		StopBits:   2,
+		DataBits:   5,
+		SampleRate: 8000,
+		OneFreq:    2125,
+		ZeroFreq:   2295,
+	}
+
+	charset := gortty.LoadCharset(&gortty.USTTY)
+
+	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)
+
+	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)
+		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)
+		m.ttyReader = NewModemReader(decoderToTTY)
+	} else {
+		m.ttyReader = os.Stdin
+		m.ttyWriter = os.Stdout
+	}
+		
+	go m.cli()
+
+	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]
+			}
+		}
+	}
+	
+}
+
+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
+}
+
+func (m *ModemWriter) Get() rune {
+	return <-m.output
+}
+
+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)
+	}
+}
+
+type configFunction func(action int, value string) string
+
+type configRegister struct {
+	help		 string
+	f configFunction
+}
+
+const (
+	registerGet = iota
+	registerSet
+)
+
+func (m *modem) cli() {
+
+	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.ttyReader)
+	
+	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.ttyWriter, "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")
+			for s, conf := range settings {
+				fmt.Fprintf(m.ttyWriter, "%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")
+				break
+			}
+			fmt.Fprintln(m.ttyWriter, "OK")
+			dataMode(netConn, ttyBufferedReader, m.ttyWriter, escapeRune)
+		case "D": // dial
+			if netConn.Connected() {
+				fmt.Fprintln(m.ttyWriter, "ERROR Session in progress")
+				break
+			}
+			addr := strings.TrimSpace(parameter)
+			
+			var err error
+			netConn, err = NewNetConn(addr)
+			if err != nil {
+				fmt.Fprintln(m.ttyWriter, "ERROR", err)
+				break
+			} else {
+				fmt.Fprintln(m.ttyWriter, "CONNECTED")
+				dataMode(netConn, ttyBufferedReader, m.ttyWriter, escapeRune)
+			}
+		case "H": // hangup
+			if !netConn.Connected() {
+				fmt.Fprintln(m.ttyWriter, "ERROR No active session")
+				break
+			}
+			netConn.Hangup()
+			fmt.Fprintln(m.ttyWriter, "OK")
+		case "E": // local echo
+			localEcho = (register == "1")
+			fmt.Fprintln(m.ttyWriter, "local echo", localEcho)
+		case "S": // local echo
+			if conf, ok := settings[register]; ok {
+				if registerQuery == "?" {
+					fmt.Fprintln(m.ttyWriter, conf.f(registerGet, ""))
+				} else if value != "" {
+					fmt.Fprintln(m.ttyWriter, conf.f(registerSet, value))
+				} else {
+					fmt.Fprintln(m.ttyWriter, "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
+	
+}
+
+
+
+
+
+
+
+
+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
+}
+
+
+
+
+
+
+
+
+
+
+