Merge pull request #16 from t-yuki/patch-1

Fix nil reference error for color map message

.circleci/config.yml

@@ -0,0 +1,129 @@
+version: 2 # use CircleCI 2.0
+jobs: # basic units of work in a run
+  build: # runs not using Workflows must have a `build` job as entry point
+    docker: # run the steps with Docker
+      # CircleCI Go images available at: https://hub.docker.com/r/circleci/golang/
+      - image: circleci/golang:1.12
+      # CircleCI PostgreSQL images available at: https://hub.docker.com/r/circleci/postgres/
+      - image: circleci/postgres:9.6-alpine
+        environment: # environment variables for primary container
+          POSTGRES_USER: circleci-demo-go
+          POSTGRES_DB: circle_test
+
+    parallelism: 2
+
+    environment: # environment variables for the build itself
+      TEST_RESULTS: /tmp/test-results # path to where test results will be saved
+
+    steps: # steps that comprise the `build` job
+      - checkout # check out source code to working directory
+      - run: mkdir -p $TEST_RESULTS # create the test results directory
+
+      - restore_cache: # restores saved cache if no changes are detected since last run
+          keys:
+            - go-mod-v4-{{ checksum "go.sum" }}
+
+      #  Wait for Postgres to be ready before proceeding
+      - run:
+          name: Waiting for Postgres to be ready
+          command: dockerize -wait tcp://localhost:5432 -timeout 1m
+
+      - run:
+          name: Run unit tests
+          environment: # environment variables for the database url and path to migration files
+            CONTACTS_DB_URL: "postgres://circleci-demo-go@localhost:5432/circle_test?sslmode=disable"
+            CONTACTS_DB_MIGRATIONS: /home/circleci/project/db/migrations
+
+          # store the results of our tests in the $TEST_RESULTS directory
+          command: |
+            PACKAGE_NAMES=$(go list ./... | circleci tests split --split-by=timings --timings-type=classname)
+            gotestsum --junitfile ${TEST_RESULTS}/gotestsum-report.xml -- $PACKAGE_NAMES
+    
+      #  Build 
+      - run:
+          name: Build and package all OS flavors
+          command: |
+              #!/bin/bash
+              sum="sha1sum"
+
+              # VERSION=`date -u +%Y%m%d`
+              VERSION="v1.11"
+              LDFLAGS="-X main.VERSION=$VERSION -s -w"
+              GCFLAGS=""
+
+              if ! hash sha1sum 2>/dev/null; then
+                if ! hash shasum 2>/dev/null; then
+                  echo "I can't see 'sha1sum' or 'shasum'"
+                  echo "Please install one of them!"
+                  exit
+                fi
+                sum="shasum"
+              fi
+
+              UPX=false
+              if hash upx 2>/dev/null; then
+                UPX=true
+              fi
+
+
+              OSES=( linux darwin windows )
+              ARCHS=(amd64 386 )
+              for os in ${OSES[@]}; do
+                for arch in ${ARCHS[@]}; do
+                  suffix=""
+                  if [ "$os" == "windows" ]
+                  then
+                    suffix=".exe"
+                  fi
+
+                  env CGO_ENABLED=0 GOOS=$os GOARCH=$arch go build -ldflags "$LDFLAGS" -gcflags "$GCFLAGS" -o ./dist/${os}_${arch}/recorder${suffix} ./recorder/cmd
+                  env CGO_ENABLED=0 GOOS=$os GOARCH=$arch go build -ldflags "$LDFLAGS" -gcflags "$GCFLAGS" -o ./dist/${os}_${arch}/player${suffix} ./player/cmd
+                  env CGO_ENABLED=0 GOOS=$os GOARCH=$arch go build -ldflags "$LDFLAGS" -gcflags "$GCFLAGS" -o ./dist/${os}_${arch}/proxy${suffix} ./proxy/cmd
+                
+                    if $UPX; then upx -9 client_${os}_${arch}${suffix} server_${os}_${arch}${suffix};fi
+                  # tar -zcf ./dist/${CIRCLE_PROJECT_REPONAME}-${os}-${arch}-$VERSION.tar.gz ./dist/${os}_${arch}/proxy${suffix} ./dist/${os}_${arch}/player${suffix} ./dist/${os}_${arch}/recorder${suffix}
+                      cd dist/${os}_${arch}/
+                      zip -D -q -r ../${CIRCLE_PROJECT_REPONAME}-${os}-${arch}-$VERSION.zip proxy${suffix} player${suffix} recorder${suffix}
+                      cd ../..
+                      export
+                    $sum ./dist/${CIRCLE_PROJECT_REPONAME}-${os}-${arch}-$VERSION.zip
+                    rm -rf ./dist/${os}_${arch}/
+                done
+              done
+
+      - store_artifacts: # upload test summary for display in Artifacts
+          path: ./dist
+          destination: release-artifacts
+
+      # - run: make # pull and build dependencies for the project
+
+      # - save_cache:
+      #     key: go-mod-v4-{{ checksum "go.sum" }}
+      #     paths:
+      #       - "/go/pkg/mod"
+
+      # - run:
+      #     name: Start service
+      #     environment:
+      #       CONTACTS_DB_URL: "postgres://circleci-demo-go@localhost:5432/circle_test?sslmode=disable"
+      #       CONTACTS_DB_MIGRATIONS: /home/circleci/project/db/migrations
+      #     command: ./workdir/contacts
+      #     background: true # keep service running and proceed to next step
+
+      # - run:
+      #     name: Validate service is working
+      #     command: |
+      #       sleep 5
+      #       curl --retry 10 --retry-delay 1 -X POST --header "Content-Type: application/json" -d '{"email":"test@example.com","name":"Test User"}' http://localhost:8080/contacts
+
+      # - store_artifacts: # upload test summary for display in Artifacts
+      #     path: /tmp/test-results
+      #     destination: raw-test-output
+
+      # - store_test_results: # upload test results for display in Test Summary
+      #     path: /tmp/test-results
+workflows:
+  version: 2
+  build-workflow:
+    jobs:
+      - build

.gitignore

@@ -2,3 +2,8 @@
 *.debug
 *.test
 debug
+/dist
+vncproxy
+prox
+cmd
+aa

README.md

@@ -1,30 +1,37 @@
-# VncProxy
-An RFB proxy, written in go that can save and replay FBS files
-* supports all modern encodings & most useful pseudo-encodings
-* supports multiple VNC client connections & multi servers (chosen by sessionId)
-* supports being a "websockify" proxy (for web clients like NoVnc)
-* produces FBS files compatible with tightvnc player (while using tight's default 3Byte color format)
-* can also be used as:
-    * a screen recorder vnc-client
-    * a replay server to show fbs recordings to connecting clients 
+# VncProxy [![CircleCI](https://circleci.com/gh/amitbet/vncproxy/tree/master.svg?style=shield)](https://circleci.com/gh/amitbet/vncproxy/tree/master) [![MIT Licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/CircleCI-Public/circleci-demo-go/master/LICENSE.md)
 
-**This is still a work in progress, and requires some error handling and general tidying up, 
-but the code is already working (see main, proxy_test & player_test)**
-- tested on tight encoding with:
+An RFB proxy, written in go that can save and replay FBS files
+* Supports all modern encodings & most useful pseudo-encodings
+* Supports multiple VNC client connections & multi servers (chosen by sessionId)
+* Supports being a "websockify" proxy (for web clients like NoVnc)
+* Produces FBS files compatible with [tightvnc's rfb player](https://www.tightvnc.com/rfbplayer.php) (while using tight's default 3Byte color format)
+* Can also be used as:
+    * A screen recorder vnc-client
+    * A replay server to show fbs recordings to connecting clients 
+    
+- Tested on tight encoding with:
     - Tightvnc (client + java client + server)
     - FBS player (tightVnc Java player)
-    - NoVnc(web client)
+    - NoVnc(web client) => use -wsPort to open a websocket
     - ChickenOfTheVnc(client)
     - VineVnc(server)
     - TigerVnc(client)
+    - Qemu vnc(server) 
 
-## Usage
-**Some very usable cmdline executables are Coming Soon...**
 
-Code samples can be found by looking at:
-* main.go (fbs recording vnc client) 
-    * Connects, records to FBS file
-    * Programmed to quit after 10 seconds
+### Executables (see releases)
+* proxy - the actual recording proxy, supports listening to tcp & ws ports and recording traffic to fbs files
+* recorder - connects to a vnc server as a client and records the screen
+* player - a toy player that will replay a given fbs file to all incoming connections
+
+## Usage:
+    recorder -recFile=./recording.rbs -targHost=192.168.0.100 -targPort=5903 -targPass=@@@@@
+    player -fbsFile=./myrec.fbs -tcpPort=5905
+    proxy -recDir=./recordings/ -targHost=192.168.0.100 -targPort=5903 -targPass=@@@@@ -tcpPort=5903 -wsPort=5905 -vncPass=@!@!@!
+
+### Code usage examples
+* player/main.go (fbs recording vnc client) 
+    * Connects as client, records to FBS file
 * proxy/proxy_test.go (vnc proxy with recording)
     * Listens to both Tcp and WS ports
     * Proxies connections to a hard-coded localhost vnc server
@@ -56,4 +63,4 @@ The Recorder uses channels and runs in parallel to avoid hampering the communica
 
 ![Image of Arch](https://github.com/amitbet/vncproxy/blob/master/architecture/player-arch.png?raw=true)
 
-The code is based on several implementations of go-vnc including the original one by *Mitchell Hashimoto*, and the recentely active fork which belongs to *Vasiliy Tolstov*.
+The code is based on several implementations of go-vnc including the original one by *Mitchell Hashimoto*, and the recentely active fork by *Vasiliy Tolstov*.

build.sh

@@ -1,4 +1,48 @@
-export GOOS="darwin"
-go build -o ./dist/recorder ./recorder/cmd
-go build -o ./dist/player ./player/cmd
-go build -o ./dist/proxy ./proxy/cmd
+#!/bin/bash
+sum="sha1sum"
+
+# VERSION=`date -u +%Y%m%d`
+VERSION="v1.11"
+LDFLAGS="-X main.VERSION=$VERSION -s -w"
+GCFLAGS=""
+
+if ! hash sha1sum 2>/dev/null; then
+	if ! hash shasum 2>/dev/null; then
+		echo "I can't see 'sha1sum' or 'shasum'"
+		echo "Please install one of them!"
+		exit
+	fi
+	sum="shasum"
+fi
+
+UPX=false
+if hash upx 2>/dev/null; then
+	UPX=true
+fi
+
+
+
+
+
+OSES=( linux darwin windows )
+ARCHS=(amd64 386 )
+for os in ${OSES[@]}; do
+	for arch in ${ARCHS[@]}; do
+		suffix=""
+		if [ "$os" == "windows" ]
+		then
+			suffix=".exe"
+		fi
+
+		env CGO_ENABLED=0 GOOS=$os GOARCH=$arch go build -ldflags "$LDFLAGS" -gcflags "$GCFLAGS" -o ./dist/${os}_${arch}/recorder${suffix} ./recorder/cmd
+		env CGO_ENABLED=0 GOOS=$os GOARCH=$arch go build -ldflags "$LDFLAGS" -gcflags "$GCFLAGS" -o ./dist/${os}_${arch}/player${suffix} ./player/cmd
+		env CGO_ENABLED=0 GOOS=$os GOARCH=$arch go build -ldflags "$LDFLAGS" -gcflags "$GCFLAGS" -o ./dist/${os}_${arch}/proxy${suffix} ./proxy/cmd
+	
+    	if $UPX; then upx -9 client_${os}_${arch}${suffix} server_${os}_${arch}${suffix};fi
+		# tar -zcf ./dist/vncproxy-${os}-${arch}-$VERSION.tar.gz ./dist/${os}_${arch}/proxy${suffix} ./dist/${os}_${arch}/player${suffix} ./dist/${os}_${arch}/recorder${suffix}
+        cd dist/${os}_${arch}/
+        zip -D -q -r ../vncproxy-${os}-${arch}-$VERSION.zip proxy${suffix} player${suffix} recorder${suffix}
+        cd ../..
+    	$sum ./dist/vncproxy-${os}-${arch}-$VERSION.zip
+	done
+done

client/client-conn.go

@@ -4,11 +4,11 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
 	"io"
 	"net"
 	"unicode"
-	"vncproxy/common"
-	"vncproxy/logger"
 )
 
 // A ServerMessage implements a message sent from the server to the client.
@@ -116,9 +116,9 @@ func (c *ClientConn) Read(bytes []byte) (n int, err error) {
 	return c.conn.Read(bytes)
 }
 
-func (c *ClientConn) CurrentColorMap() *common.ColorMap {
-	return &c.ColorMap
-}
+// func (c *ClientConn) CurrentColorMap() *common.ColorMap {
+// 	return &c.ColorMap
+// }
 
 // CutText tells the server that the client has new text in its cut buffer.
 // The text string MUST only contain Latin-1 characters. This encoding
@@ -146,7 +146,7 @@ func (c *ClientConn) CutText(text string) error {
 
 	for _, char := range text {
 		if char > unicode.MaxLatin1 {
-			return fmt.Errorf("Character '%s' is not valid Latin-1", char)
+			return fmt.Errorf("Character '%v' is not valid Latin-1", char)
 		}
 
 		if err := binary.Write(&buf, binary.BigEndian, uint8(char)); err != nil {
@@ -474,6 +474,7 @@ func (c *ClientConn) mainLoop() {
 		new(MsgSetColorMapEntries),
 		new(MsgBell),
 		new(MsgServerCutText),
+		new(MsgServerFence),
 	}
 
 	for _, msg := range defaultMessages {
@@ -506,7 +507,7 @@ func (c *ClientConn) mainLoop() {
 			// Unsupported message type! Bad!
 			break
 		}
-		logger.Infof("ClientConn.MainLoop: got ServerMessage:%s", common.ServerMessageType(messageType))
+		logger.Debugf("ClientConn.MainLoop: got ServerMessage:%s", common.ServerMessageType(messageType))
 		reader.SendMessageStart(common.ServerMessageType(messageType))
 		reader.PublishBytes([]byte{byte(messageType)})
 

client/pixel-format.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 func readPixelFormat(r io.Reader, result *common.PixelFormat) error {

client/server-messages.go

@@ -6,9 +6,9 @@ import (
 	"fmt"
 	"io"
 	"strings"
-	"vncproxy/common"
-	"vncproxy/encodings"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/encodings"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 // MsgFramebufferUpdate consists of a sequence of rectangles of
@@ -63,7 +63,7 @@ func (fbm *MsgFramebufferUpdate) Read(c common.IClientConn, r *common.RfbReadHel
 	// We must always support the raw encoding
 	rawEnc := new(encodings.RawEncoding)
 	encMap[rawEnc.Type()] = rawEnc
-	logger.Infof("MsgFramebufferUpdate.Read: numrects= %d", numRects)
+	logger.Debugf("MsgFramebufferUpdate.Read: numrects= %d", numRects)
 
 	rects := make([]common.Rectangle, numRects)
 	for i := uint16(0); i < numRects; i++ {
@@ -90,7 +90,7 @@ func (fbm *MsgFramebufferUpdate) Read(c common.IClientConn, r *common.RfbReadHel
 
 		encType := common.EncodingType(encodingTypeInt)
 
-		logger.Infof("MsgFramebufferUpdate.Read: rect# %d, rect hdr data: enctype=%s, data: %s", i, encType, string(jBytes))
+		logger.Debugf("MsgFramebufferUpdate.Read: rect# %d, rect hdr data: enctype=%s, data: %s", i, encType, string(jBytes))
 		enc, supported := encMap[encodingTypeInt]
 		if supported {
 			var err error
@@ -129,7 +129,7 @@ type MsgSetColorMapEntries struct {
 }
 
 func (fbm *MsgSetColorMapEntries) CopyTo(r io.Reader, w io.Writer, c common.IClientConn) error {
-	reader := &common.RfbReadHelper{Reader: r}
+	reader := common.NewRfbReadHelper(r)
 	writeTo := &WriteTo{w, "MsgSetColorMapEntries.CopyTo"}
 	reader.Listeners.AddListener(writeTo)
 	_, err := fbm.Read(c, reader)
@@ -175,9 +175,9 @@ func (m *MsgSetColorMapEntries) Read(c common.IClientConn, r *common.RfbReadHelp
 				return nil, err
 			}
 		}
-		cmap := c.CurrentColorMap()
-		// Update the connection's color map
-		cmap[result.FirstColor+i] = *color
+		// cmap := c.CurrentColorMap()
+		// // Update the connection's color map
+		// cmap[result.FirstColor+i] = *color
 	}
 	r.SendMessageEnd(common.ServerMessageType(m.Type()))
 	return &result, nil

client/write-to.go

@@ -2,8 +2,8 @@ package client
 
 import (
 	"io"
-	"vncproxy/common"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 type WriteTo struct {

common/client-message-type.go

@@ -17,7 +17,8 @@ const (
 	KeyEventMsgType
 	PointerEventMsgType
 	ClientCutTextMsgType
-	ClientFenceMsgType = 248
+	ClientFenceMsgType          = 248
+	QEMUExtendedKeyEventMsgType = 255
 )
 
 // Color represents a single color in a color map.
@@ -47,6 +48,8 @@ func (cmt ClientMessageType) String() string {
 		return "FramebufferUpdateRequest"
 	case KeyEventMsgType:
 		return "KeyEvent"
+	case QEMUExtendedKeyEventMsgType:
+		return "QEMUExtendedKeyEvent"
 	case PointerEventMsgType:
 		return "PointerEvent"
 	case ClientCutTextMsgType:

common/conn-interfaces.go

@@ -25,6 +25,6 @@ type IServerConn interface {
 
 type IClientConn interface {
 	CurrentPixelFormat() *PixelFormat
-	CurrentColorMap() *ColorMap
+	//CurrentColorMap() *ColorMap
 	Encodings() []IEncoding
 }

common/encoding.go

@@ -73,6 +73,8 @@ func (enct EncodingType) String() string {
 		return "EncJPEGQualityLevelPseudo1"
 	case EncCursorPseudo:
 		return "EncCursorPseudo"
+	case EncLedStatePseudo:
+		return "EncLedStatePseudo"
 	case EncDesktopSizePseudo:
 		return "EncDesktopSizePseudo"
 	case EncLastRectPseudo:
@@ -183,6 +185,7 @@ const (
 	EncQEMUPointerMotionChangePseudo EncodingType = -257
 	EncQEMUExtendedKeyEventPseudo    EncodingType = -258
 	EncTightPng                      EncodingType = -260
+	EncLedStatePseudo                EncodingType = -261
 	EncExtendedDesktopSizePseudo     EncodingType = -308
 	EncXvpPseudo                     EncodingType = -309
 	EncFencePseudo                   EncodingType = -312

common/rfb-reader-helper.go

@@ -5,7 +5,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"io"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 var TightMinToCompress = 12

encodings/enc-copy-rect.go

@@ -3,7 +3,7 @@ package encodings
 import (
 	"encoding/binary"
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 type CopyRectEncoding struct {

encodings/enc-corre.go

@@ -3,7 +3,7 @@ package encodings
 import (
 	"encoding/binary"
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 type CoRREEncoding struct {

encodings/enc-cursor-pseudo.go

@@ -3,7 +3,7 @@ package encodings
 import (
 	"io"
 	"math"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 type EncCursorPseudo struct {

encodings/enc-hextile.go

@@ -2,8 +2,8 @@ package encodings
 
 import (
 	"io"
-	"vncproxy/common"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 const (

encodings/enc-led-state.go

@@ -0,0 +1,31 @@
+package encodings
+
+import (
+	"io"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
+)
+
+type EncLedStatePseudo struct {
+	LedState uint8
+}
+
+func (pe *EncLedStatePseudo) Type() int32 {
+	return int32(common.EncLedStatePseudo)
+}
+func (pe *EncLedStatePseudo) WriteTo(w io.Writer) (n int, err error) {
+	w.Write([]byte{pe.LedState})
+	return 1, nil
+}
+func (pe *EncLedStatePseudo) Read(pf *common.PixelFormat, rect *common.Rectangle, r *common.RfbReadHelper) (common.IEncoding, error) {
+	if rect.Width*rect.Height == 0 {
+		return pe, nil
+	}
+	u8, err := r.ReadUint8()
+	pe.LedState = u8
+	if err != nil {
+		logger.Error("error while reading led state: ", err)
+		return pe, err
+	}
+	return pe, nil
+}

encodings/enc-pseudo.go

@@ -2,7 +2,7 @@ package encodings
 
 import (
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 type PseudoEncoding struct {

encodings/enc-raw.go

@@ -3,7 +3,7 @@ package encodings
 import (
 	"bytes"
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 // RawEncoding is raw pixel data sent by the server.

encodings/enc-rre.go

@@ -3,7 +3,7 @@ package encodings
 import (
 	"encoding/binary"
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 type RREEncoding struct {

encodings/enc-tight.go

@@ -4,8 +4,8 @@ import (
 	"bytes"
 	"errors"
 	"io"
-	"vncproxy/common"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 var TightMinToCompress int = 12
@@ -142,7 +142,7 @@ func handleTightFilters(subencoding uint8, pixelFmt *common.PixelFormat, rect *c
 			return
 		}
 
-		paletteSize := colorCount + 1 // add one more
+		paletteSize := int(colorCount) + 1 // add one more
 		logger.Debugf("handleTightFilters: ----PALETTE_FILTER: paletteSize=%d bytesPixel=%d\n", paletteSize, bytesPixel)
 		//complete palette
 		_, err = r.ReadBytes(int(paletteSize) * bytesPixel)
@@ -155,7 +155,7 @@ func handleTightFilters(subencoding uint8, pixelFmt *common.PixelFormat, rect *c
 		if paletteSize == 2 {
 			dataLength = int(rect.Height) * ((int(rect.Width) + 7) / 8)
 		} else {
-			dataLength = int(rect.Width * rect.Height)
+			dataLength = int(rect.Width) * int(rect.Height)
 		}
 		_, err = r.ReadTightData(dataLength)
 		if err != nil {

encodings/enc-tightpng.go

@@ -3,8 +3,8 @@ package encodings
 import (
 	"fmt"
 	"io"
-	"vncproxy/common"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 type TightPngEncoding struct {

encodings/enc-zlib.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 type ZLibEncoding struct {

encodings/enc-zrle.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 type ZRLEEncoding struct {

go.mod

@@ -0,0 +1,3 @@
+module github.com/amitbet/vncproxy
+
+require golang.org/x/net v0.0.0-20181129055619-fae4c4e3ad76

go.sum

@@ -0,0 +1,2 @@
+golang.org/x/net v0.0.0-20181129055619-fae4c4e3ad76 h1:xx5MUFyRQRbPk6VjWjIE1epE/K5AoDD8QUN116NCy8k=
+golang.org/x/net v0.0.0-20181129055619-fae4c4e3ad76/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=

logger/logger.go

@@ -4,6 +4,30 @@ import "fmt"
 
 var simpleLogger = SimpleLogger{LogLevelInfo}
 
+func SetLogLevel(logLevel string) {
+	level := GetLogLevel(logLevel)
+	fmt.Println("Log level set to: ", logLevel)
+	simpleLogger = SimpleLogger{level}
+}
+
+func GetLogLevel(logLevel string) LogLevel {
+	switch logLevel {
+	case "trace":
+		return LogLevelTrace
+	case "debug":
+		return LogLevelDebug
+	case "info":
+		return LogLevelInfo
+	case "warn":
+		return LogLevelWarn
+	case "error":
+		return LogLevelError
+	case "fatal":
+		return LogLevelFatal
+	}
+	return LogLevelInfo
+}
+
 type Logger interface {
 	Debug(v ...interface{})
 	Debugf(format string, v ...interface{})
@@ -127,6 +151,13 @@ func Debugf(format string, v ...interface{}) {
 	simpleLogger.Debugf(format, v...)
 }
 
+func Trace(v ...interface{}) {
+	simpleLogger.Trace(v...)
+}
+func Tracef(format string, v ...interface{}) {
+	simpleLogger.Tracef(format, v...)
+}
+
 func Info(v ...interface{}) {
 	simpleLogger.Info(v...)
 }

player/cmd/main.go

@@ -4,19 +4,21 @@ import (
 	"flag"
 	"fmt"
 	"os"
-	"vncproxy/common"
-	"vncproxy/encodings"
-	"vncproxy/logger"
-	"vncproxy/player"
-	"vncproxy/server"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/encodings"
+	"github.com/amitbet/vncproxy/logger"
+	"github.com/amitbet/vncproxy/player"
+	"github.com/amitbet/vncproxy/server"
 )
 
 func main() {
 	wsPort := flag.String("wsPort", "", "websocket port for player to listen to client connections")
 	tcpPort := flag.String("tcpPort", "", "tcp port for player to listen to client connections")
 	fbsFile := flag.String("fbsFile", "", "fbs file to serve to all connecting clients")
+	logLevel := flag.String("logLevel", "info", "change logging level")
 
 	flag.Parse()
+	logger.SetLogLevel(*logLevel)
 
 	fmt.Println("**************************************************************************")
 	fmt.Println("*** This is a toy server that replays a single FBS file to all clients ***")
@@ -80,7 +82,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	url := "http://localhost:" + *wsPort + "/"
+	url := "http://0.0.0.0:" + *wsPort + "/"
 
 	if *tcpPort != "" && *wsPort != "" {
 		logger.Infof("running two listeners: tcp port: %s, ws url: %s", *tcpPort, url)

player/fbs-play-listener.go

@@ -3,17 +3,25 @@ package player
 import (
 	"encoding/binary"
 
+	"io"
 	"time"
-	"vncproxy/client"
-	"vncproxy/common"
-
-	"vncproxy/logger"
-	"vncproxy/server"
+	"github.com/amitbet/vncproxy/client"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
+	"github.com/amitbet/vncproxy/server"
 )
 
+type VncStreamFileReader interface {
+	io.Reader
+	CurrentTimestamp() int
+	ReadStartSession() (*common.ServerInit, error)
+	CurrentPixelFormat() *common.PixelFormat
+	Encodings() []common.IEncoding
+}
+
 type FBSPlayListener struct {
 	Conn             *server.ServerConn
-	Fbs              *FbsReader
+	Fbs              VncStreamFileReader
 	serverMessageMap map[uint8]common.ServerMessage
 	firstSegDone     bool
 	startTime        int
@@ -88,7 +96,7 @@ func (h *FBSPlayListener) sendFbsMessage() {
 		return
 	}
 	timeSinceStart := int(time.Now().UnixNano()/int64(time.Millisecond)) - h.startTime
-	timeToSleep := fbs.currentTimestamp - timeSinceStart
+	timeToSleep := fbs.CurrentTimestamp() - timeSinceStart
 	if timeToSleep > 0 {
 		time.Sleep(time.Duration(timeToSleep) * time.Millisecond)
 	}

player/fbs-reader.go

@@ -5,9 +5,9 @@ import (
 	"encoding/binary"
 	"io"
 	"os"
-	"vncproxy/common"
-	"vncproxy/encodings"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/encodings"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 type FbsReader struct {
@@ -18,6 +18,10 @@ type FbsReader struct {
 	encodings        []common.IEncoding
 }
 
+func (fbs *FbsReader) CurrentTimestamp() int {
+	return fbs.currentTimestamp
+}
+
 func (fbs *FbsReader) Read(p []byte) (n int, err error) {
 	if fbs.buffer.Len() < len(p) {
 		seg, err := fbs.ReadSegment()
@@ -33,8 +37,9 @@ func (fbs *FbsReader) Read(p []byte) (n int, err error) {
 }
 
 func (fbs *FbsReader) CurrentPixelFormat() *common.PixelFormat { return fbs.pixelFormat }
-func (fbs *FbsReader) CurrentColorMap() *common.ColorMap       { return &common.ColorMap{} }
-func (fbs *FbsReader) Encodings() []common.IEncoding           { return fbs.encodings }
+
+//func (fbs *FbsReader) CurrentColorMap() *common.ColorMap       { return &common.ColorMap{} }
+func (fbs *FbsReader) Encodings() []common.IEncoding { return fbs.encodings }
 
 func NewFbsReader(fbsFile string) (*FbsReader, error) {
 
@@ -53,6 +58,7 @@ func NewFbsReader(fbsFile string) (*FbsReader, error) {
 			&encodings.TightEncoding{},
 			&encodings.TightPngEncoding{},
 			&encodings.EncCursorPseudo{},
+			&encodings.EncLedStatePseudo{},
 			&encodings.RawEncoding{},
 			&encodings.RREEncoding{},
 		},

player/player_test.go

@@ -3,14 +3,15 @@ package player
 import (
 	"testing"
 	"time"
-	"vncproxy/common"
-	"vncproxy/encodings"
-	"vncproxy/logger"
-	"vncproxy/server"
+
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/encodings"
+	"github.com/amitbet/vncproxy/logger"
+	"github.com/amitbet/vncproxy/server"
 )
 
 func TestServer(t *testing.T) {
-
+	t.Skip("this isn't an automated test, just an entrypoint for debugging")
 	//chServer := make(chan common.ClientMessage)
 	//chClient := make(chan common.ServerMessage)
 
@@ -18,6 +19,7 @@ func TestServer(t *testing.T) {
 		&encodings.RawEncoding{},
 		&encodings.TightEncoding{},
 		&encodings.EncCursorPseudo{},
+		&encodings.EncLedStatePseudo{},
 		//encodings.TightPngEncoding{},
 		&encodings.RREEncoding{},
 		&encodings.ZLibEncoding{},

proxy/cmd/main.go

@@ -1,9 +1,13 @@
 package main
 
-import "vncproxy/proxy"
-import "flag"
-import "vncproxy/logger"
-import "os"
+import (
+	"flag"
+	"os"
+	"path/filepath"
+
+	"github.com/amitbet/vncproxy/logger"
+	vncproxy "github.com/amitbet/vncproxy/proxy"
+)
 
 func main() {
 	//create default session if required
@@ -11,10 +15,14 @@ func main() {
 	var wsPort = flag.String("wsPort", "", "websocket port")
 	var vncPass = flag.String("vncPass", "", "password on incoming vnc connections to the proxy, defaults to no password")
 	var recordDir = flag.String("recDir", "", "path to save FBS recordings WILL NOT RECORD if not defined.")
-	var targetVncPort = flag.String("targPort", "", "target vnc server port")
+	var targetVnc = flag.String("target", "", "target vnc server (host:port or /path/to/unix.socket)")
+	var targetVncPort = flag.String("targPort", "", "target vnc server port (deprecated, use -target)")
+	var targetVncHost = flag.String("targHost", "", "target vnc server host (deprecated, use -target)")
 	var targetVncPass = flag.String("targPass", "", "target vnc password")
+	var logLevel = flag.String("logLevel", "info", "change logging level")
 
 	flag.Parse()
+	logger.SetLogLevel(*logLevel)
 
 	if *tcpPort == "" && *wsPort == "" {
 		logger.Error("no listening port defined")
@@ -22,8 +30,8 @@ func main() {
 		os.Exit(1)
 	}
 
-	if *targetVncPort == "" {
-		logger.Error("no target vnc server port defined")
+	if *targetVnc == "" && *targetVncPort == "" {
+		logger.Error("no target vnc server host/port or socket defined")
 		flag.Usage()
 		os.Exit(1)
 	}
@@ -31,25 +39,42 @@ func main() {
 	if *vncPass == "" {
 		logger.Warn("proxy will have no password")
 	}
-	if *recordDir == "" {
-		logger.Warn("FBS recording is turned off")
-	}
 
-	proxy := &proxy.VncProxy{
-		WsListeningUrl:   "http://localhost:" + string(*wsPort) + "/", // empty = not listening on ws
-		RecordingDir:     *recordDir,                                  //"/Users/amitbet/vncRec",                     // empty = no recording
-		TcpListeningUrl:  ":" + string(*tcpPort),
+	tcpURL := ""
+	if *tcpPort != "" {
+		tcpURL = ":" + string(*tcpPort)
+	}
+	wsURL := ""
+	if *wsPort != "" {
+		wsURL = "http://0.0.0.0:" + string(*wsPort) + "/"
+	}
+	proxy := &vncproxy.VncProxy{
+		WsListeningURL:   wsURL, // empty = not listening on ws
+		TCPListeningURL:  tcpURL,
 		ProxyVncPassword: *vncPass, //empty = no auth
-		SingleSession: &proxy.VncSession{
-			TargetHostname: "localhost",
+		SingleSession: &vncproxy.VncSession{
+			Target:         *targetVnc,
+			TargetHostname: *targetVncHost,
 			TargetPort:     *targetVncPort,
 			TargetPassword: *targetVncPass, //"vncPass",
 			ID:             "dummySession",
-			Status:         proxy.SessionStatusInit,
-			Type:           proxy.SessionTypeRecordingProxy,
+			Status:         vncproxy.SessionStatusInit,
+			Type:           vncproxy.SessionTypeProxyPass,
 		}, // to be used when not using sessions
 		UsingSessions: false, //false = single session - defined in the var above
 	}
 
+	if *recordDir != "" {
+		fullPath, err := filepath.Abs(*recordDir)
+		if err != nil {
+			logger.Error("bad recording path: ", err)
+		}
+		logger.Info("FBS recording is turned on, writing to dir: ", fullPath)
+		proxy.RecordingDir = fullPath
+		proxy.SingleSession.Type = vncproxy.SessionTypeRecordingProxy
+	} else {
+		logger.Info("FBS recording is turned off")
+	}
+
 	proxy.StartListening()
 }

proxy/message-listeners.go

@@ -1,10 +1,10 @@
 package proxy
 
 import (
-	"vncproxy/client"
-	"vncproxy/common"
-	"vncproxy/logger"
-	"vncproxy/server"
+	"github.com/amitbet/vncproxy/client"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
+	"github.com/amitbet/vncproxy/server"
 )
 
 type ClientUpdater struct {
@@ -13,7 +13,7 @@ type ClientUpdater struct {
 
 // Consume recieves vnc-server-bound messages (Client messages) and updates the server part of the proxy
 func (cc *ClientUpdater) Consume(seg *common.RfbSegment) error {
-	//logger.Debugf("ClientUpdater.Consume (vnc-server-bound): got segment type=%s bytes: %v", seg.SegmentType, seg.Bytes)
+	logger.Tracef("ClientUpdater.Consume (vnc-server-bound): got segment type=%s bytes: %v", seg.SegmentType, seg.Bytes)
 	switch seg.SegmentType {
 
 	case common.SegmentFullyParsedClientMessage:

proxy/proxy.go

@@ -5,18 +5,19 @@ import (
 	"path"
 	"strconv"
 	"time"
-	"vncproxy/client"
-	"vncproxy/common"
-	"vncproxy/encodings"
-	"vncproxy/logger"
-	"vncproxy/player"
-	listeners "vncproxy/recorder"
-	"vncproxy/server"
+
+	"github.com/amitbet/vncproxy/client"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/encodings"
+	"github.com/amitbet/vncproxy/logger"
+	"github.com/amitbet/vncproxy/player"
+	listeners "github.com/amitbet/vncproxy/recorder"
+	"github.com/amitbet/vncproxy/server"
 )
 
 type VncProxy struct {
-	TcpListeningUrl  string      // empty = not listening on tcp
-	WsListeningUrl   string      // empty = not listening on ws
+	TCPListeningURL  string      // empty = not listening on tcp
+	WsListeningURL   string      // empty = not listening on ws
 	RecordingDir     string      // empty = no recording
 	ProxyVncPassword string      //empty = no auth
 	SingleSession    *VncSession // to be used when not using sessions
@@ -24,8 +25,17 @@ type VncProxy struct {
 	sessionManager   *SessionManager
 }
 
-func (vp *VncProxy) createClientConnection(targetServerUrl string, vncPass string) (*client.ClientConn, error) {
-	nc, err := net.Dial("tcp", targetServerUrl)
+func (vp *VncProxy) createClientConnection(target string, vncPass string) (*client.ClientConn, error) {
+	var (
+		nc  net.Conn
+		err error
+	)
+
+	if target[0] == '/' {
+		nc, err = net.Dial("unix", target)
+	} else {
+		nc, err = net.Dial("tcp", target)
+	}
 
 	if err != nil {
 		logger.Errorf("error connecting to vnc server: %s", err)
@@ -62,7 +72,7 @@ func (vp *VncProxy) getProxySession(sessionId string) (*VncSession, error) {
 }
 
 func (vp *VncProxy) newServerConnHandler(cfg *server.ServerConfig, sconn *server.ServerConn) error {
-
+	var err error
 	session, err := vp.getProxySession(sconn.SessionId)
 	if err != nil {
 		logger.Errorf("Proxy.newServerConnHandler can't get session: %d", sconn.SessionId)
@@ -70,10 +80,11 @@ func (vp *VncProxy) newServerConnHandler(cfg *server.ServerConfig, sconn *server
 	}
 
 	var rec *listeners.Recorder
+
 	if session.Type == SessionTypeRecordingProxy {
 		recFile := "recording" + strconv.FormatInt(time.Now().Unix(), 10) + ".rbs"
 		recPath := path.Join(vp.RecordingDir, recFile)
-		rec, err := listeners.NewRecorder(recPath)
+		rec, err = listeners.NewRecorder(recPath)
 		if err != nil {
 			logger.Errorf("Proxy.newServerConnHandler can't open recorder save path: %s", recPath)
 			return err
@@ -84,7 +95,12 @@ func (vp *VncProxy) newServerConnHandler(cfg *server.ServerConfig, sconn *server
 
 	session.Status = SessionStatusInit
 	if session.Type == SessionTypeProxyPass || session.Type == SessionTypeRecordingProxy {
-		cconn, err := vp.createClientConnection(session.TargetHostname+":"+session.TargetPort, session.TargetPassword)
+		target := session.Target
+		if session.TargetHostname != "" && session.TargetPort != "" {
+			target = session.TargetHostname + ":" + session.TargetPort
+		}
+
+		cconn, err := vp.createClientConnection(target, session.TargetPassword)
 		if err != nil {
 			session.Status = SessionStatusError
 			logger.Errorf("Proxy.newServerConnHandler error creating connection: %s", err)
@@ -117,6 +133,7 @@ func (vp *VncProxy) newServerConnHandler(cfg *server.ServerConfig, sconn *server
 			&encodings.RawEncoding{},
 			&encodings.TightEncoding{},
 			&encodings.EncCursorPseudo{},
+			&encodings.EncLedStatePseudo{},
 			&encodings.TightPngEncoding{},
 			&encodings.RREEncoding{},
 			&encodings.ZLibEncoding{},
@@ -169,19 +186,19 @@ func (vp *VncProxy) StartListening() {
 		UseDummySession:  !vp.UsingSessions,
 	}
 
-	if vp.TcpListeningUrl != "" && vp.WsListeningUrl != "" {
-		logger.Infof("running two listeners: tcp port: %s, ws url: %s", vp.TcpListeningUrl, vp.WsListeningUrl)
+	if vp.TCPListeningURL != "" && vp.WsListeningURL != "" {
+		logger.Infof("running two listeners: tcp port: %s, ws url: %s", vp.TCPListeningURL, vp.WsListeningURL)
 
-		go server.WsServe(vp.WsListeningUrl, cfg)
-		server.TcpServe(":"+vp.TcpListeningUrl, cfg)
+		go server.WsServe(vp.WsListeningURL, cfg)
+		server.TcpServe(vp.TCPListeningURL, cfg)
 	}
 
-	if vp.WsListeningUrl != "" {
-		logger.Infof("running ws listener url: %s", vp.WsListeningUrl)
-		server.WsServe(vp.WsListeningUrl, cfg)
+	if vp.WsListeningURL != "" {
+		logger.Infof("running ws listener url: %s", vp.WsListeningURL)
+		server.WsServe(vp.WsListeningURL, cfg)
 	}
-	if vp.TcpListeningUrl != "" {
-		logger.Infof("running tcp listener on port: %s", vp.TcpListeningUrl)
-		server.TcpServe(":"+vp.TcpListeningUrl, cfg)
+	if vp.TCPListeningURL != "" {
+		logger.Infof("running tcp listener on port: %s", vp.TCPListeningURL)
+		server.TcpServe(vp.TCPListeningURL, cfg)
 	}
 }

proxy/proxy_test.go

@@ -4,17 +4,18 @@ import "testing"
 
 func TestProxy(t *testing.T) {
 	//create default session if required
+	t.Skip("this isn't an automated test, just an entrypoint for debugging")
 
 	proxy := &VncProxy{
-		WsListeningUrl:  "http://localhost:7777/", // empty = not listening on ws
-		RecordingDir:    "/Users/amitbet/vncRec",  // empty = no recording
-		TcpListeningUrl: ":5904",
-		//recordingDir:          "C:\\vncRec", // empty = no recording
+		WsListeningURL:  "http://0.0.0.0:7778/", // empty = not listening on ws
+		RecordingDir:    "d:\\",                 // empty = no recording
+		TCPListeningURL: ":5904",
+		//RecordingDir:          "C:\\vncRec", // empty = no recording
 		ProxyVncPassword: "1234", //empty = no auth
 		SingleSession: &VncSession{
-			TargetHostname: "localhost",
-			TargetPort:     "5903",
-			TargetPassword: "Ch_#!T@8",
+			TargetHostname: "192.168.1.101",
+			TargetPort:     "5901",
+			TargetPassword: "123456",
 			ID:             "dummySession",
 			Status:         SessionStatusInit,
 			Type:           SessionTypeRecordingProxy,

proxy/vnc-session.go

@@ -16,6 +16,7 @@ const (
 )
 
 type VncSession struct {
+	Target         string
 	TargetHostname string
 	TargetPort     string
 	TargetPassword string

recorder/cmd/main.go

@@ -5,22 +5,31 @@ import (
 	"net"
 	"os"
 	"time"
-	"vncproxy/client"
-	"vncproxy/common"
-	"vncproxy/encodings"
-	"vncproxy/logger"
-	"vncproxy/recorder"
+	"github.com/amitbet/vncproxy/client"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/encodings"
+	"github.com/amitbet/vncproxy/logger"
+	"github.com/amitbet/vncproxy/recorder"
 )
 
 func main() {
 	// var tcpPort = flag.String("tcpPort", "", "tcp port")
 	// var wsPort = flag.String("wsPort", "", "websocket port")
 	// var vncPass = flag.String("vncPass", "", "password on incoming vnc connections to the proxy, defaults to no password")
-	var recordDir = flag.String("recDir", "", "path to save FBS recordings WILL NOT RECORD IF EMPTY.")
+	var recordDir = flag.String("recFile", "", "FBS file to create, recordings WILL NOT RECORD IF EMPTY.")
 	var targetVncPort = flag.String("targPort", "", "target vnc server port")
 	var targetVncPass = flag.String("targPass", "", "target vnc password")
+	var targetVncHost = flag.String("targHost", "localhost", "target vnc hostname")
+	var logLevel = flag.String("logLevel", "info", "change logging level")
 
 	flag.Parse()
+	logger.SetLogLevel(*logLevel)
+
+	if *targetVncHost == "" {
+		logger.Error("no target vnc server host defined")
+		flag.Usage()
+		os.Exit(1)
+	}
 
 	if *targetVncPort == "" {
 		logger.Error("no target vnc server port defined")
@@ -33,10 +42,12 @@ func main() {
 	}
 	if *recordDir == "" {
 		logger.Warn("FBS recording is turned off")
+	} else {
+		logger.Infof("Recording rfb stream into file: '%s'", *recordDir)
 	}
 
 	//nc, err := net.Dial("tcp", "192.168.1.101:5903")
-	nc, err := net.Dial("tcp", "localhost:"+*targetVncPort)
+	nc, err := net.Dial("tcp", *targetVncHost+":"+*targetVncPort)
 
 	if err != nil {
 		logger.Errorf("error connecting to vnc server: %s", err)
@@ -74,9 +85,9 @@ func main() {
 	encs := []common.IEncoding{
 		&encodings.TightEncoding{},
 		//&encodings.TightPngEncoding{},
-		//rre := encodings.RREEncoding{},
-		//zlib := encodings.ZLibEncoding{},
-		//zrle := encodings.ZRLEEncoding{},
+		//&encodings.RREEncoding{},
+		//&encodings.ZLibEncoding{},
+		//&encodings.ZRLEEncoding{},
 		//&encodings.CopyRectEncoding{},
 		//coRRE := encodings.CoRREEncoding{},
 		//hextile := encodings.HextileEncoding{},

recorder/recorder.go

@@ -5,9 +5,9 @@ import (
 	"encoding/binary"
 	"os"
 	"time"
-	"vncproxy/common"
-	"vncproxy/logger"
-	"vncproxy/server"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
+	"github.com/amitbet/vncproxy/server"
 )
 
 type Recorder struct {
@@ -38,7 +38,7 @@ func NewRecorder(saveFilePath string) (*Recorder, error) {
 
 	rec.maxWriteSize = 65535
 
-	rec.writer, err = os.OpenFile(saveFilePath, os.O_RDWR|os.O_CREATE, 0755)
+	rec.writer, err = os.OpenFile(saveFilePath, os.O_RDWR|os.O_CREATE, 0644)
 	if err != nil {
 		logger.Errorf("unable to open file: %s, error: %v", saveFilePath, err)
 		return nil, err

recorder/rfb-requester.go

@@ -2,9 +2,9 @@ package recorder
 
 import (
 	"time"
-	"vncproxy/client"
-	"vncproxy/common"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/client"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 type RfbRequester struct {

server/client-messages.go

@@ -3,7 +3,7 @@ package server
 import (
 	"encoding/binary"
 	"io"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 // Key represents a VNC key press.
@@ -165,6 +165,36 @@ func (msg *MsgKeyEvent) Write(c io.Writer) error {
 	return nil
 }
 
+// MsgKeyEvent holds the wire format message.
+type MsgQEMUExtKeyEvent struct {
+	SubmessageType uint8  // submessage type
+	DownFlag       uint16 // down-flag
+	KeySym         Key    // key symbol
+	KeyCode        uint32 // scan code
+}
+
+func (*MsgQEMUExtKeyEvent) Type() common.ClientMessageType {
+	return common.QEMUExtendedKeyEventMsgType
+}
+
+func (*MsgQEMUExtKeyEvent) Read(c io.Reader) (common.ClientMessage, error) {
+	msg := MsgKeyEvent{}
+	if err := binary.Read(c, binary.BigEndian, &msg); err != nil {
+		return nil, err
+	}
+	return &msg, nil
+}
+
+func (msg *MsgQEMUExtKeyEvent) Write(c io.Writer) error {
+	if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil {
+		return err
+	}
+	if err := binary.Write(c, binary.BigEndian, msg); err != nil {
+		return err
+	}
+	return nil
+}
+
 // PointerEventMessage holds the wire format message.
 type MsgPointerEvent struct {
 	Mask uint8  // button-mask
@@ -280,3 +310,34 @@ func (msg *MsgClientCutText) Write(c io.Writer) error {
 
 	return nil
 }
+
+// MsgClientQemuExtendedKey holds the wire format message, for qemu keys
+type MsgClientQemuExtendedKey struct {
+	SubType  uint8   // sub type
+	IsDown   uint16 // button down indicator
+	KeySym   uint32 // key symbol
+	KeyCode  uint32 // key code
+}
+
+func (*MsgClientQemuExtendedKey) Type() common.ClientMessageType {
+	return common.QEMUExtendedKeyEventMsgType
+}
+
+func (*MsgClientQemuExtendedKey) Read(c io.Reader) (common.ClientMessage, error) {
+	msg := MsgClientQemuExtendedKey{}
+
+	if err := binary.Read(c, binary.BigEndian, &msg); err != nil {
+		return nil, err
+	}
+	return &msg, nil
+}
+
+func (msg *MsgClientQemuExtendedKey) Write(c io.Writer) error {
+	if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil {
+		return err
+	}
+	if err := binary.Write(c, binary.BigEndian, msg); err != nil {
+		return err
+	}
+	return nil
+}

server/handlers.go

@@ -3,10 +3,10 @@ package server
 import (
 	"encoding/binary"
 	"fmt"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 
 	"io"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 const ProtoVersionLength = 12
@@ -95,7 +95,7 @@ func ServerSecurityHandler(cfg *ServerConfig, c *ServerConn) error {
 
 	sType, ok := secTypes[secType]
 	if !ok {
-		return fmt.Errorf("server type %d not implemented")
+		return fmt.Errorf("server type %d not implemented", secType)
 	}
 
 	var authCode uint32
@@ -135,7 +135,7 @@ func ServerServerInitHandler(cfg *ServerConfig, c *ServerConn) error {
 		NameLength:  uint32(len(cfg.DesktopName)),
 		NameText:    []byte(cfg.DesktopName),
 	}
-	logger.Infof("Server.ServerServerInitHandler initMessage: %v", srvInit)
+	logger.Debugf("Server.ServerServerInitHandler initMessage: %v", srvInit)
 	if err := binary.Write(c, binary.BigEndian, srvInit.FBWidth); err != nil {
 		return err
 	}

server/security.go

@@ -6,7 +6,7 @@ import (
 	"crypto/rand"
 	"errors"
 	"log"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 type SecurityType uint8

server/server-conn.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"io"
 	"sync"
-	"vncproxy/common"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/logger"
 )
 
 type ServerConn struct {
@@ -168,16 +168,17 @@ func (c *ServerConn) handle() error {
 		default:
 			var messageType common.ClientMessageType
 			if err := binary.Read(c, binary.BigEndian, &messageType); err != nil {
-				logger.Errorf("IServerConn.handle error: %v", err)
+				logger.Errorf("ServerConn.handle error: %v", err)
 				return err
 			}
+			logger.Debugf("ServerConn.handle: got messagetype, %d", messageType)
 			msg, ok := clientMessages[messageType]
+			logger.Debugf("ServerConn.handle: found message type, %v", ok)
 			if !ok {
-				return fmt.Errorf("IServerConn.Handle: unsupported message-type: %v", messageType)
+				logger.Errorf("ServerConn.handle: unsupported message-type: %v", messageType)
 			}
-
 			parsedMsg, err := msg.Read(c)
-
+			logger.Debugf("ServerConn.handle: got parsed messagetype, %v", parsedMsg)
 			//update connection for pixel format / color map changes
 			switch parsedMsg.Type() {
 			case common.SetPixelFormatMsgType:
@@ -196,7 +197,7 @@ func (c *ServerConn) handle() error {
 				return err
 			}
 
-			logger.Infof("IServerConn.Handle got ClientMessage: %s, %v", parsedMsg.Type(), parsedMsg)
+			logger.Debugf("IServerConn.Handle got ClientMessage: %s, %v", parsedMsg.Type(), parsedMsg)
 			//TODO: treat set encodings by allowing only supported encoding in proxy configurations
 			//// if parsedMsg.Type() == common.SetEncodingsMsgType{
 			//// 	c.cfg.Encodings

server/server.go

@@ -5,7 +5,7 @@ import (
 	"io"
 	"log"
 	"net"
-	"vncproxy/common"
+	"github.com/amitbet/vncproxy/common"
 )
 
 var DefaultClientMessages = []common.ClientMessage{
@@ -15,6 +15,7 @@ var DefaultClientMessages = []common.ClientMessage{
 	&MsgKeyEvent{},
 	&MsgPointerEvent{},
 	&MsgClientCutText{},
+	&MsgClientQemuExtendedKey{},
 }
 
 // FramebufferUpdate holds a FramebufferUpdate wire format message.

server/server_test.go

@@ -3,8 +3,9 @@ package server
 import (
 	"log"
 	"testing"
-	"vncproxy/common"
-	"vncproxy/encodings"
+
+	"github.com/amitbet/vncproxy/common"
+	"github.com/amitbet/vncproxy/encodings"
 )
 
 func newServerConnHandler(cfg *ServerConfig, conn *ServerConn) error {
@@ -13,6 +14,7 @@ func newServerConnHandler(cfg *ServerConfig, conn *ServerConn) error {
 }
 
 func TestServer(t *testing.T) {
+	t.Skip("this isn't an automated test, just an entrypoint for debugging")
 
 	//chServer := make(chan common.ClientMessage)
 	chClient := make(chan common.ServerMessage)

server/ws-server-go.go

@@ -4,7 +4,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"vncproxy/logger"
+	"github.com/amitbet/vncproxy/logger"
 
 	"golang.org/x/net/websocket"
 )

todo.md

@@ -6,4 +6,11 @@
 * code stuff:
     * move encodings to be on the framebufferupdate message object
     * clear all messages read functions from updating stuff, move modification logic to another listener
-    * message read function should accept only an io.Reader, move read helper logic (readuint8) to an actual helper class
+    * message read function should accept only an io.Reader, move read helper logic (readuint8) to an actual helper class
+* new recording format:
+    * rfb extension
+    * save FBResponse messages with additional fields
+        * timestamp
+        * is incremental
+        * size (bytes)
+    * have a header which contains an index of messages, holding timestamps & file positions for seeking