Implement auto restart of server, Print Apdu

Author: viduq

apdu.go

@@ -3,6 +3,7 @@ package vv104
 import (
 	"bytes"
 	"errors"
+	"fmt"
 )
 
 type Apdu struct {
@@ -26,6 +27,21 @@ func (apdu Apdu) CheckApdu() (bool, error) {
 	return true, nil
 }
 
+func (apdu Apdu) String() string {
+	switch apdu.Apci.FrameFormat {
+
+	case IFormatFrame:
+		fmt.Println("this is an i frame!")
+		return apdu.Asdu.String()
+	case SFormatFrame:
+		return fmt.Sprintf("S-Format (%d/%d)\n", apdu.Apci.Rsn, apdu.Apci.Ssn)
+	case UFormatFrame:
+		return apdu.Apci.UFormat.String()
+
+	}
+	return ""
+}
+
 func (apdu *Apdu) Serialize(state State) []byte {
 	asduBuf := new(bytes.Buffer)
 	apciBuf := new(bytes.Buffer)
@@ -101,6 +117,7 @@ func ParseApdu(buf *bytes.Buffer) (Apdu, error) {
 
 	// ctrl field 1
 	b, _ = buf.ReadByte()
+	fmt.Println("byte ctrl field 1:", b)
 	if (b & 0b0000_0001) == 0b0000_0000 {
 		// i frame
 		apdu.Apci.FrameFormat = IFormatFrame

cmd/main.go

@@ -11,8 +11,6 @@ func main() {
 	state := vv104.NewState()
 	state.Start()
 
-	fmt.Println(state)
-
 	fmt.Println("vv140 finished.")
 }
 

connection.go

@@ -1,6 +1,7 @@
 package vv104
 
 import (
+	"bytes"
 	"fmt"
 	"net"
 	"time"
@@ -19,24 +20,52 @@ func (state *State) startConnection() {
 }
 
 func (state *State) startServer() {
+	fmt.Println("startServer started")
+	defer fmt.Println("startServer returned")
+
 	var err error
-	var l net.Listener
-	ipAndPort := state.Config.Ipv4Addr + ":" + fmt.Sprint(state.Config.Port)
-	l, err = net.Listen("tcp", ipAndPort)
+
+	ipAndPortStr := state.Config.Ipv4Addr + ":" + fmt.Sprint(state.Config.Port)
+	ipAndPort, err := net.ResolveTCPAddr("tcp", ipAndPortStr)
+	if err != nil {
+		panic(err)
+	}
+
+	var l *net.TCPListener
+	l, err = net.ListenTCP("tcp", ipAndPort)
+	l.SetDeadline(time.Now().Add(2 * time.Second))
+	defer l.Close()
+
 	if err != nil {
 		panic(err)
 	}
 
-	// state.wg.Add(1)
+	state.wg.Add(1)
+	defer state.wg.Done()
+
 	for {
-		conn, err := l.Accept()
-		if err != nil {
-			fmt.Println(err)
-			time.Sleep(time.Second * 2)
-			continue
+		select {
+		default:
+
+			conn, err := l.Accept()
+			if err != nil {
+				if err, ok := err.(*net.OpError); ok && err.Timeout() {
+					// it was a timeout
+				}
+				// other problem
+				fmt.Println(err)
+				continue
+			}
+			fmt.Println("Connected from: ", conn.RemoteAddr())
+			go state.handleConnection(conn)
+
+			<-state.ctx.Done() // todo? other criteria?
+			return
+
+		case <-state.ctx.Done():
+			fmt.Println("startServer received Done(), returns")
+			return
 		}
-		fmt.Println("Connected from: ", conn.RemoteAddr())
-		go state.handleConnection(conn)
 	}
 
 }
@@ -46,16 +75,14 @@ func (state *State) startClient() {
 }
 
 func (state *State) handleConnection(conn net.Conn) {
+	fmt.Println("handleConnection started")
+	defer fmt.Println("handleConnection returned")
 	defer conn.Close()
-
+	var bytesbuf bytes.Buffer
 	buf := make([]byte, 256) // todo: read whole tcp frame
 	state.wg.Add(1)
 	defer state.wg.Done()
 
-	// err := conn.SetReadDeadline(time.Now().Add(3 * time.Second))
-	// if err != nil {
-	// 	panic(err)
-	// }
 	for {
 		select {
 
@@ -71,14 +98,22 @@ func (state *State) handleConnection(conn net.Conn) {
 					continue
 				}
 				fmt.Println("Error reading:", err.Error())
-				fmt.Println("Restart because of error reading")
+				fmt.Println("Restart because of error reading, handleConnection returns")
 				state.cancel()
 				return
 			}
-			fmt.Println(buf[:recvLen])
+
+			bytesbuf.Write(buf[:recvLen]) // Read from conn directly into bytesbuf?
+			fmt.Println(bytesbuf)
+			apdu, err := ParseApdu(&bytesbuf)
+			if err != nil {
+				fmt.Println("error parsing:", err)
+			} else {
+				fmt.Println("<<RX:", apdu)
+			}
 
 		case <-state.ctx.Done():
-			fmt.Println("handleConnection received Done(), quitting")
+			fmt.Println("handleConnection received Done(), returns")
 			return
 		}
 	}

iec104Constants.go

@@ -24,6 +24,8 @@ const (
 type UFormat byte
 
 // U-Format types
+//
+//go:generate stringer -type=UFormat
 const (
 	StartDTAct UFormat = 0x07
 	StartDTCon UFormat = 0x0b

interactive_control.go

@@ -5,10 +5,10 @@ import (
 	"os"
 )
 
-func (state *State) readCommandsFromStdIn() {
+func readCommandsFromStdIn(fromStdInchan chan string) {
 	sc := bufio.NewScanner(os.Stdin)
 
 	for sc.Scan() {
-		state.chans.commandsFromStdin <- sc.Text()
+		fromStdInchan <- sc.Text()
 	}
 }

state.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"sync"
+	"time"
 )
 
 type State struct {
@@ -24,7 +25,6 @@ type AllChans struct {
 	commandsFromStdin chan string
 	received          chan Apdu
 	toSend            chan Apdu
-	quit              chan bool
 }
 
 const (
@@ -63,16 +63,34 @@ func NewState() State {
 func (state *State) Start() {
 	state.Config.ParseFlags()
 	state.chans.commandsFromStdin = make(chan string, 30)
-	state.chans.received = make(chan Apdu, state.Config.W)
-	state.chans.toSend = make(chan Apdu, state.Config.K)
-	state.ctx, state.cancel = context.WithCancel(context.Background())
+	go readCommandsFromStdIn(state.chans.commandsFromStdin) // never exits
 
-	go state.readCommandsFromStdIn()
-	go state.startConnection()
+	for {
+		state.chans.received = make(chan Apdu, state.Config.W)
+		state.chans.toSend = make(chan Apdu, state.Config.K)
+		state.ctx, state.cancel = context.WithCancel(context.Background())
+		go state.startConnection()
+
+		select {
+		case input := <-state.chans.commandsFromStdin:
+
+			if input == "exit" {
+				fmt.Println("called exit")
+				state.cancel()
+				state.wg.Wait()
+				fmt.Println("Start() exited")
+				return
+			}
+
+		case <-state.ctx.Done():
+			state.wg.Wait()
+			fmt.Println("Restart!")
+			time.Sleep(1500 * time.Millisecond)
+			continue
+
+		}
+	}
 
-	// state.wg.Wait()
-	<-state.chans.quit
-	fmt.Println("Start() exited")
 }
 
 func incrementSeqNumber(seqNumber SeqNumber) SeqNumber {