Changed write to handle locking.

OSWrite handles writing out to the caller.
Write handles ANSI (and should also handle)
the CR=>CRNL translations. (TODO).

door/door.go

@@ -90,7 +90,7 @@ type Mouse struct {
 	Y      int8
 }
 
-type MouseMode int
+type MouseMode int16
 
 const (
 	Off      MouseMode = 0
@@ -115,11 +115,25 @@ func (*noCopy) Unlock() {}
 	noCopy         noCopy
 */
 
+type BaseWriter struct {
+	Closed             bool
+	TranslateNL        bool
+	TranslateToUnicode bool
+	nlBuffer           *bytes.Buffer
+	uniBuffer          *bytes.Buffer
+	ansiCSI            bool
+	ansiCode           []byte
+	LastSavedColor     []int
+}
+
 type Door struct {
 	Config        DropfileConfig
 	READFD        int
 	WRITEFD       int
-	Writer        OSWriter
+	Writer        OSWriter         // OS specific writer
+	writeMutex    sync.Mutex       // Writer lock
+	ansiCSI       bool             // ANSI CSI
+	ansiCode      []byte           // ANSI CSI Codes
 	Disconnected  bool             // Has User disconnected/Hung up?
 	TimeOut       time.Time        // Fixed point in time, when time expires
 	StartTime     time.Time        // Time when User started door
@@ -132,9 +146,9 @@ type Door struct {
 	LastMouse     []Mouse          // Store Mouse information
 	LastCursor    []CursorPos      // Store Cursor pos information
 	mcMutex       sync.Mutex       // Lock for LastMouse, LastCursor
-	wg            sync.WaitGroup
-	tio_default   *term.State // Terminal State to restore
-	Mouse         MouseMode   // Mouse mode enabled
+	wg            sync.WaitGroup   // Reader finished
+	tio_default   *term.State      // Terminal State to restore
+	Mouse         MouseMode        // Mouse mode enabled
 }
 
 /*

door/panel.go

@@ -116,7 +116,7 @@ func (p *Panel) Clear() []byte {
 	var row int = p.Y
 	var blank []byte
 
-	if style > 0 {
+	if p.HasBorder() {
 		blank = bytes.Repeat([]byte{' '}, p.Width+2)
 		p.output.Write(Goto(p.X, row))
 		p.output.Write(blank)
@@ -147,12 +147,12 @@ func (p *Panel) Output() []byte {
 	}
 	p.output.Reset()
 
-	if style > 0 {
+	if p.HasBorder() {
 		box_style = &BOXES[style-1]
 	}
 
 	var row int = p.Y
-	if style > 0 {
+	if p.HasBorder() {
 		// Top line / border
 		p.output.Write(Goto(p.X, row))
 		p.output.WriteString(p.BorderColor)
@@ -175,7 +175,7 @@ func (p *Panel) Output() []byte {
 
 		var joined bool = false
 
-		if style > 0 {
+		if p.HasBorder() {
 			top := box_style.Top
 			if bytes.Compare(line.Text.Bytes()[0:len(top)], []byte(top)) == 0 {
 				// Yes, this line needs to be joined...
@@ -187,7 +187,7 @@ func (p *Panel) Output() []byte {
 		}
 
 		if !joined {
-			if style > 0 {
+			if p.HasBorder() {
 				p.output.WriteString(p.BorderColor + box_style.Side)
 			}
 			p.output.Write(line.Output())
@@ -199,7 +199,7 @@ func (p *Panel) Output() []byte {
 		row++
 	}
 
-	if style > 0 {
+	if p.HasBorder() {
 		// Bottom / border
 		p.output.Write(Goto(p.X, row))
 		p.output.WriteString(p.BorderColor + box_style.Bottom_Left)
@@ -241,14 +241,14 @@ func (p *Panel) UpdateLine(index int) []byte {
 		p.output = &bytes.Buffer{}
 	}
 	p.output.Reset()
-	var style int = int(p.Style)
+	// var style int = int(p.Style)
 
 	p.Lines[index].Update()
 	var row, col int
 
 	row = p.Y + index
 	col = p.X
-	if style > 0 {
+	if p.HasBorder() {
 		row++
 		col++
 	}

door/write.go

@@ -2,6 +2,7 @@ package door
 
 import (
 	"bytes"
+	"fmt"
 	"log"
 	"regexp"
 	"strconv"
@@ -60,11 +61,17 @@ func ParseColorArray(colorarray []int) ANSIColorParts {
 	acp.FG = -1
 	acp.BG = -1
 
+	if len(colorarray) == 0 {
+		colorarray = []int{0}
+	}
+
 	for _, c := range colorarray {
 		switch c {
 		case 0:
 			acp.FG = 7
 			acp.BG = 0
+			acp.Bold = false
+			acp.Blink = false
 		case 1:
 			acp.Bold = true
 		case 5:
@@ -148,63 +155,228 @@ func (d *Door) WriteS(output string) {
 }
 
 func (d *Door) WriteA(a ...interface{}) {
-	d.Writer.Mutex.Lock()
-	defer d.Writer.Mutex.Unlock()
+	d.writeMutex.Lock()
+	defer d.writeMutex.Unlock()
 
 	for _, item := range a {
 		switch item.(type) {
 		case string:
-			d.Writer.OSWrite([]byte(item.(string)))
+			d.LockedWrite([]byte(item.(string)))
 		case []byte:
-			d.Writer.OSWrite(item.([]byte))
+			d.LockedWrite(item.([]byte))
 		case *bytes.Buffer:
-			d.Writer.OSWrite(item.(*bytes.Buffer).Bytes())
+			d.LockedWrite(item.(*bytes.Buffer).Bytes())
 		default:
 			log.Printf("Unknown/unsupported type: %T\n", item)
 		}
 	}
 }
 
-func (d *Door) Write(output []byte) {
-	if len(output) == 0 {
-		return
+func EndCSI(c byte) bool {
+	return (c >= 0x40) && (c <= 0x7f)
+}
+
+func (d *Door) ANSIProcess() {
+	var csi byte = d.ansiCode[len(d.ansiCode)-1]
+
+	switch csi {
+	case 's':
+		// Save Color
+		var slen int = len(d.LastColor)
+		if cap(d.Writer.LastSavedColor) < slen {
+			d.Writer.LastSavedColor = make([]int, slen)
+		} else {
+			d.Writer.LastSavedColor = d.Writer.LastSavedColor[0:slen]
+		}
+		copy(d.Writer.LastSavedColor, d.LastColor)
+		log.Printf("ColorSave: %d\n", d.Writer.LastSavedColor)
+	case 'u':
+		// Restore Color
+		var slen int = len(d.Writer.LastSavedColor)
+		if cap(d.LastColor) < slen {
+			d.LastColor = make([]int, slen)
+		} else {
+			d.LastColor = d.LastColor[0:slen]
+		}
+		copy(d.LastColor, d.Writer.LastSavedColor)
+		log.Printf("ColorRestore: %d\n", d.LastColor)
+	case 'm':
+		// Process color code
+		var color [5]int
+		var cpos int
+		var code int
+		var pos int
+		for pos = 0; pos < len(d.ansiCode); pos++ {
+			var b byte = d.ansiCode[pos]
+			switch b {
+			case ';':
+				color[cpos] = code
+				code = 0
+				cpos++
+			case '1', '2', '3', '4', '5', '6', '7', '8', '9', '0':
+				code *= 10
+				code += int(b - '0')
+			}
+		}
+
+		if code != 0 {
+			color[cpos] = code
+			code = 0
+			cpos++
+		}
+
+		// Make sure there is always at least one code here.
+		if cpos == 0 {
+			color[cpos] = 0
+			cpos++
+		}
+
+		log.Printf("color: [%d]", color[0:cpos])
+		var newColor = ParseColorArray(d.LastColor)
+		for _, c := range color[0:cpos] {
+			switch c {
+			case 0:
+				newColor.FG = 7
+				newColor.BG = 0
+				newColor.Bold = false
+				newColor.Blink = false
+			case 1:
+				newColor.Bold = true
+			case 5:
+				newColor.Blink = true
+			case 30, 31, 32, 33, 34, 35, 36, 37:
+				newColor.FG = c - 30
+			case 40, 41, 42, 43, 44, 45, 46, 47:
+				newColor.BG = c - 40
+			}
+		}
+
+		// Reset LastColor
+		d.LastColor = d.LastColor[0:0]
+		d.LastColor = append(d.LastColor, 0)
+		if newColor.Blink {
+			d.LastColor = append(d.LastColor, 5)
+		}
+		if newColor.Bold {
+			d.LastColor = append(d.LastColor, 1)
+		}
+		if newColor.FG != -1 {
+			d.LastColor = append(d.LastColor, newColor.FG+30)
+		}
+		if newColor.BG != -1 {
+			d.LastColor = append(d.LastColor, newColor.BG+40)
+		}
+		log.Printf("LastColor: [%d]", d.LastColor)
 	}
 
-	d.Writer.Write(output)
-	/*
-		d.
-		d.writerMutex.Lock()
-		defer d.writerMutex.Unlock()
-		if d.WriterClosed {
+	var outputByte [20]byte
+	var output []byte = outputByte[0:0]
+
+	output = fmt.Appendf(output, "ANSI: [%q]\n", d.ansiCode)
+	log.Printf("%s", output)
+	d.ansiCode = d.ansiCode[0:0]
+	d.ansiCSI = false
+}
+
+func (d *Door) ANSIScan(output []byte) {
+	var pos, nextpos int
+	var olen int = len(output)
+	var c byte
+
+	if d.ansiCSI {
+		for pos < olen {
+			c = output[pos]
+			d.ansiCode = append(d.ansiCode, c)
+			pos++
+			if EndCSI(c) {
+				d.ANSIProcess()
+				break
+			}
+		}
+
+		if pos == olen {
 			return
+			// pos == -1 // end
 		}
+	}
 
-		if strings.HasSuffix(output, RestorePos) {
-			output += Color(d.LastColor)
+	for pos != -1 {
+		nextpos = bytes.Index(output[pos:], []byte{'\x1b'})
+		if nextpos != -1 {
+			// Found ESC
+			nextpos += pos + 1
 
+			if output[nextpos] == '[' {
+				d.ansiCSI = true
+				nextpos++
+				for nextpos < olen {
+					c = output[nextpos]
+					d.ansiCode = append(d.ansiCode, c)
+					nextpos++
+					if EndCSI(c) {
+						d.ANSIProcess()
+						break
+					}
+				}
+			}
+			pos = nextpos
 		} else {
-			d.UpdateLastColor(output, &d.LastColor)
+			return
 		}
+	}
+}
+
+func (d *Door) LockedWrite(output []byte) {
+	if d.writeMutex.TryLock() {
+		log.Panic("LockedWrite: mutex was NOT locked.")
+	}
 
-		d.OSWrite([]byte(output))
+	// var lastColorBytes [32]byte
+	var lastColor string // []byte = lastColorBytes[0:0]
+	/*
+		if (bytes.HasPrefix(output, []byte(SavePos))) &&
+			(bytes.HasSuffix(output, []byte(RestorePos))) {
 	*/
+	/*
+		if bytes.HasSuffix(output, []byte(RestorePos)) {
+			// Write the current color
+			lastColor = Color(d.LastColor)
+			//fmt.Append(lastColor, []byte(Color(d.LastColor)))
+			log.Printf("Restore LastColor: %d => %q", d.LastColor, lastColor)
+		}
+	*/
+
+	log.Printf(">> %q\n", output)
+	d.Writer.Write(output)
+	d.ANSIScan(output)
+
+	if bytes.HasSuffix(output, []byte(RestorePos)) {
+		lastColor = Color(d.LastColor)
+		//fmt.Append(lastColor, []byte(Color(d.LastColor)))
+		log.Printf("Restore LastColor: %d => %q", d.LastColor, lastColor)
+		d.Writer.Write([]byte(lastColor))
+		d.ANSIScan([]byte(lastColor))
+	}
+	/*
+		if len(lastColor) != 0 {
+			log.Println("Restored HERE...")
+			d.Writer.Write([]byte(lastColor))
+			d.ANSIScan([]byte(lastColor))
+		}
+	*/
+	// else {
+	// Only update if we're NOT restoring...
+	// Update
+	// d.ANSIScan(output)
+	// }
 }
 
-// This uses go routine Writer. (Deprecated)
-// Write string to client.
-/*
-func (d *Door) WriteCh(output string) {
-	if output == "" {
-		// That was easy.
+func (d *Door) Write(output []byte) {
+	if len(output) == 0 {
 		return
 	}
 
-	defer func() {
-		if err := recover(); err != nil {
-			log.Println("Write failed.", err)
-		}
-	}()
-
-	d.writerChannel <- output
+	d.writeMutex.Lock()
+	defer d.writeMutex.Unlock()
+	d.LockedWrite(output)
 }
-*/

door/write_linux.go

@@ -2,8 +2,6 @@ package door
 
 import (
 	"bytes"
-	"log"
-	"sync"
 	"syscall"
 )
 
@@ -11,13 +9,8 @@ import (
 // This assumes that d.writerMutex is locked.
 
 type OSWriter struct {
-	Mutex              sync.Mutex // Writer mutex
-	Closed             bool
-	Handle             int
-	TranslateNL        bool
-	TranslateToUnicode bool
-	nlBuffer           *bytes.Buffer
-	uniBuffer          *bytes.Buffer
+	Handle int
+	BaseWriter
 }
 
 func (ow *OSWriter) Init(d *Door) {
@@ -25,12 +18,19 @@ func (ow *OSWriter) Init(d *Door) {
 	ow.Handle = d.Config.Comm_handle
 	ow.TranslateNL = true // Yes, translate NL => CR+NL
 	ow.nlBuffer = &bytes.Buffer{}
+	// ow.restoreBuff = &bytes.Buffer{}
+	ow.ansiCode = make([]byte, 0, 32)
 }
 
 func (ow *OSWriter) CP437toUnicode(output []byte) []byte {
 	if ow.uniBuffer == nil {
 		ow.uniBuffer = &bytes.Buffer{}
 	}
+	for _, ch := range output {
+		// Perform translation here
+		ow.uniBuffer.WriteByte(ch)
+	}
+
 	return ow.uniBuffer.Bytes()
 }
 
@@ -56,16 +56,108 @@ func (ow *OSWriter) NewLines(output []byte) []byte {
 	return ow.nlBuffer.Bytes()
 }
 
-// The low-lever writer function
-func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
-	var buff []byte = buffer
+/*
+// Read byte slice, add color restore (after restorepos).
+func (ow *OSWriter) HandleRestoreColor(output []byte) []byte {
+	// Parse out ANSI codes:
+	// Look for m (color), s (savepos), u (restorepos)
+	// Possibly H (goto)
+	ow.restoreBuff.Reset()
+	var changed bool
+	var pos, nextpos int
+	var outputLen int = len(output)
+
+	// Handle the case where the CSI code continues...
+	if ow.ansiCSI {
+		// Continue processing CSI code
+		var c byte
+		for pos != outputLen {
+			c = output[pos]
+			pos++
+			ow.ansiCode = append(ow.ansiCode, c)
+			if (c >= 0x40) && (c <= 0x7f) {
+				// Found it
+				ow.ansiCSI = false
+				break
+			}
+		}
+		ow.restoreBuff.Write(output[0:pos])
+		pos++
+		if !ow.ansiCSI {
+			log.Printf("CSI: %c [%q]\n", c, ow.ansiCode)
+			// Process this code (if of interest)
+			// Reset the buffer
+			ow.ansiCode = ow.ansiCode[0:0]
+		}
+	}
 
-	if DEBUG_DOOR {
-		if ow.Mutex.TryLock() {
-			log.Panic("OSWrite: mutex was NOT locked.")
+	// To verify that we're keeping the buffer in the proper state
+	changed = true
+
+	log.Printf("raw: [%q]\n", output)
+
+	for pos != -1 {
+		nextpos = bytes.Index(output[pos:], []byte{'\x1b'})
+		if nextpos != -1 {
+			nextpos += pos
+			// Output everything up to the \x1b
+			ow.restoreBuff.Write(output[pos:nextpos])
+
+			// Found ESC
+			if output[nextpos+1] == '[' {
+				// Found CSI start
+				// https://en.wikipedia.org/wiki/ANSI_escape_code#CSI_(Control_Sequence_Introducer)_sequences
+				ow.ansiCSI = true
+				// While not the end, and not end of CSI, append to ansiCode
+				var csiPos int = nextpos + 2
+				var c byte
+				for csiPos != outputLen {
+					c = output[csiPos]
+					csiPos++
+					ow.ansiCode = append(ow.ansiCode, c)
+					if (c >= 0x40) && (c <= 0x7f) {
+						// FOUND IT!
+						ow.ansiCSI = false
+						break
+					}
+				}
+
+				// Write out the CSI code (or what we have of it)
+				ow.restoreBuff.Write(output[nextpos:csiPos])
+				nextpos = csiPos
+
+				if !ow.ansiCSI {
+					log.Printf("CSI: %c [%q]\n", c, ow.ansiCode)
+					// Process this code (if of interest)
+					// Reset the buffer
+					ow.ansiCode = ow.ansiCode[0:0]
+				}
+			} else {
+				ow.restoreBuff.WriteByte('\x1b')
+				nextpos++
+			}
+
+			pos = nextpos
+		} else {
+			ow.restoreBuff.Write(output[pos:])
+			pos = nextpos // -1 (end)
 		}
 	}
 
+	// log.Printf("<< [%q]\n>> [%q]\n", output, ow.restoreBuff.Bytes())
+
+	if changed {
+		return ow.restoreBuff.Bytes()
+	} else {
+		return output
+	}
+}
+*/
+
+// The low-lever writer function
+func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
+	var buff []byte = buffer
+
 	// Filters (!)
 
 	if ow.TranslateNL {
@@ -84,37 +176,19 @@ func (ow *OSWriter) OSWrite(buffer []byte) (int, error) {
 }
 
 func (ow *OSWriter) Write(buffer []byte) (int, error) {
-	ow.Mutex.Lock()
-	defer ow.Mutex.Unlock()
 	if ow.Closed {
 		return 0, ErrDisconnected
 	}
 
-	// var output bytes.Buffer
-	// output.Write(buffer)
-	// Where should this be done?  (I think in here)
-	// TO FIX: TO DO:
-	/*
-		if bytes.HasSuffix(buffer, []byte(RestorePos)) {
-			output.WriteString(Color(d.LastColor))
-			// output += Color(d.LastColor)
-		} else {
-			d.UpdateLastColor(output, &d.LastColor)
-		}
-	*/
 	return ow.OSWrite(buffer)
 }
 
 func (ow *OSWriter) Stop() {
-	ow.Mutex.Lock()
-	defer ow.Mutex.Unlock()
 	ow.Closed = true
 }
 
 // Safe way to check if OSWriter is closed
 func (ow *OSWriter) IsClosed() bool {
-	ow.Mutex.Lock()
-	defer ow.Mutex.Unlock()
 	return ow.Closed
 }