filtering pseudo encodings and setting custom compression levels

README.md

@@ -11,22 +11,18 @@ An RFB proxy, written in go that can save and replay FBS files
 - Tested on tight encoding with:
     - Tightvnc (client + java client + server)
     - FBS player (tightVnc Java player)
-    - NoVnc(web client) => use -wsPort to open a websocket
+    - NoVnc(web client)
     - ChickenOfTheVnc(client)
     - VineVnc(server)
     - TigerVnc(client)
 
+## Usage:
 
 ### 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 -recDir=./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

build.sh

@@ -2,7 +2,7 @@
 sum="sha1sum"
 
 # VERSION=`date -u +%Y%m%d`
-VERSION="v1.02"
+VERSION="v1.0"
 LDFLAGS="-X main.VERSION=$VERSION -s -w"
 GCFLAGS=""
 
@@ -24,8 +24,8 @@ fi
 
 
 
-OSES=( linux darwin windows )
-ARCHS=(amd64 386 )
+OSES=(linux darwin windows freebsd)
+ARCHS=(amd64 386)
 for os in ${OSES[@]}; do
 	for arch in ${ARCHS[@]}; do
 		suffix=""

client/client-conn.go

@@ -506,7 +506,7 @@ func (c *ClientConn) mainLoop() {
 			// Unsupported message type! Bad!
 			break
 		}
-		logger.Debugf("ClientConn.MainLoop: got ServerMessage:%s", common.ServerMessageType(messageType))
+		logger.Infof("ClientConn.MainLoop: got ServerMessage:%s", common.ServerMessageType(messageType))
 		reader.SendMessageStart(common.ServerMessageType(messageType))
 		reader.PublishBytes([]byte{byte(messageType)})
 

client/server-messages.go

@@ -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.Debugf("MsgFramebufferUpdate.Read: numrects= %d", numRects)
+	logger.Infof("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.Debugf("MsgFramebufferUpdate.Read: rect# %d, rect hdr data: enctype=%s, data: %s", i, encType, string(jBytes))
+		logger.Infof("MsgFramebufferUpdate.Read: rect# %d, rect hdr data: enctype=%s, data: %s", i, encType, string(jBytes))
 		enc, supported := encMap[encodingTypeInt]
 		if supported {
 			var err error

common/client-message-type.go

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

common/encoding.go

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

encodings/enc-cursor-pseudo.go

@@ -4,6 +4,7 @@ import (
 	"io"
 	"math"
 	"vncproxy/common"
+	"vncproxy/logger"
 )
 
 type EncCursorPseudo struct {
@@ -21,6 +22,8 @@ func (pe *EncCursorPseudo) Read(pf *common.PixelFormat, rect *common.Rectangle,
 	}
 
 	bytesPixel := int(pf.BPP / 8) //calcTightBytePerPixel(pf)
+	logger.Infof("EncCursorPseudo bytesPerPixel= %d", bytesPixel)
+
 	r.ReadBytes(int(rect.Width*rect.Height) * bytesPixel)
 	mask := ((rect.Width + 7) / 8) * rect.Height
 	r.ReadBytes(int(math.Floor(float64(mask))))

encodings/enc-led-state.go

@@ -1,31 +0,0 @@
-package encodings
-
-import (
-	"io"
-	"vncproxy/common"
-	"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-tight.go

@@ -142,7 +142,7 @@ func handleTightFilters(subencoding uint8, pixelFmt *common.PixelFormat, rect *c
 			return
 		}
 
-		paletteSize := int(colorCount) + 1 // add one more
+		paletteSize := 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) * int(rect.Height)
+			dataLength = int(rect.Width * rect.Height)
 		}
 		_, err = r.ReadTightData(dataLength)
 		if err != nil {

logger/logger.go

@@ -4,30 +4,6 @@ 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{})
@@ -151,13 +127,6 @@ 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

@@ -15,10 +15,8 @@ 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 ***")
@@ -82,7 +80,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	url := "http://0.0.0.0:" + *wsPort + "/"
+	url := "http://localhost:" + *wsPort + "/"
 
 	if *tcpPort != "" && *wsPort != "" {
 		logger.Infof("running two listeners: tcp port: %s, ws url: %s", *tcpPort, url)

player/fbs-reader.go

@@ -58,7 +58,6 @@ func NewFbsReader(fbsFile string) (*FbsReader, error) {
 			&encodings.TightEncoding{},
 			&encodings.TightPngEncoding{},
 			&encodings.EncCursorPseudo{},
-			&encodings.EncLedStatePseudo{},
 			&encodings.RawEncoding{},
 			&encodings.RREEncoding{},
 		},

player/player_test.go

@@ -18,7 +18,6 @@ func TestServer(t *testing.T) {
 		&encodings.RawEncoding{},
 		&encodings.TightEncoding{},
 		&encodings.EncCursorPseudo{},
-		&encodings.EncLedStatePseudo{},
 		//encodings.TightPngEncoding{},
 		&encodings.RREEncoding{},
 		&encodings.ZLibEncoding{},

proxy/cmd/main.go

@@ -14,10 +14,8 @@ func main() {
 	var targetVncPort = flag.String("targPort", "", "target vnc server port")
 	var targetVncHost = flag.String("targHost", "", "target vnc server host")
 	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")
@@ -37,15 +35,15 @@ func main() {
 	if *recordDir == "" {
 		logger.Warn("FBS recording is turned off")
 	}
-
+	
 	tcpUrl := ""
 	if *tcpPort != "" {
 		tcpUrl = ":" + string(*tcpPort)
 	}
 
 	proxy := &proxy.VncProxy{
-		WsListeningUrl:   "http://0.0.0.0:" + string(*wsPort) + "/", // empty = not listening on ws
-		RecordingDir:     *recordDir,                                //"/Users/amitbet/vncRec",                     // empty = no recording
+		WsListeningUrl:   "http://localhost:" + string(*wsPort) + "/", // empty = not listening on ws
+		RecordingDir:     *recordDir,                                  //"/Users/amitbet/vncRec",                     // empty = no recording
 		TcpListeningUrl:  tcpUrl,
 		ProxyVncPassword: *vncPass, //empty = no auth
 		SingleSession: &proxy.VncSession{

proxy/message-listeners.go

@@ -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.Tracef("ClientUpdater.Consume (vnc-server-bound): got segment type=%s bytes: %v", seg.SegmentType, seg.Bytes)
+	//logger.Debugf("ClientUpdater.Consume (vnc-server-bound): got segment type=%s bytes: %v", seg.SegmentType, seg.Bytes)
 	switch seg.SegmentType {
 
 	case common.SegmentFullyParsedClientMessage:

proxy/proxy.go

@@ -118,7 +118,6 @@ func (vp *VncProxy) newServerConnHandler(cfg *server.ServerConfig, sconn *server
 			&encodings.RawEncoding{},
 			&encodings.TightEncoding{},
 			&encodings.EncCursorPseudo{},
-			&encodings.EncLedStatePseudo{},
 			&encodings.TightPngEncoding{},
 			&encodings.RREEncoding{},
 			&encodings.ZLibEncoding{},

proxy/proxy_test.go

@@ -6,15 +6,15 @@ func TestProxy(t *testing.T) {
 	//create default session if required
 
 	proxy := &VncProxy{
-		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
+		WsListeningUrl:  "http://localhost:8183/", // empty = not listening on ws
+		RecordingDir:    "",                       //"/Users/amitbet/vncRec",  // empty = no recording
+		TcpListeningUrl: ":5905",
+		//recordingDir:          "C:\\vncRec", // empty = no recording
+		ProxyVncPassword: "", //empty = no auth
 		SingleSession: &VncSession{
 			TargetHostname: "192.168.1.101",
-			TargetPort:     "5901",
-			TargetPassword: "123456",
+			TargetPort:     "5900",
+			TargetPassword: "ancient1", //"Ch_#!T@8", //
 			ID:             "dummySession",
 			Status:         SessionStatusInit,
 			Type:           SessionTypeRecordingProxy,

recorder/cmd/main.go

@@ -16,14 +16,12 @@ 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("recFile", "", "FBS file to create, recordings WILL NOT RECORD IF EMPTY.")
+	var recordDir = flag.String("recDir", "", "path to save FBS 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")
@@ -42,8 +40,6 @@ 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")
@@ -85,9 +81,9 @@ func main() {
 	encs := []common.IEncoding{
 		&encodings.TightEncoding{},
 		//&encodings.TightPngEncoding{},
-		//&encodings.RREEncoding{},
-		//&encodings.ZLibEncoding{},
-		//&encodings.ZRLEEncoding{},
+		//rre := encodings.RREEncoding{},
+		//zlib := encodings.ZLibEncoding{},
+		//zrle := encodings.ZRLEEncoding{},
 		//&encodings.CopyRectEncoding{},
 		//coRRE := encodings.CoRREEncoding{},
 		//hextile := encodings.HextileEncoding{},

recorder/recorder.go

@@ -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, 0644)
+	rec.writer, err = os.OpenFile(saveFilePath, os.O_RDWR|os.O_CREATE, 0755)
 	if err != nil {
 		logger.Errorf("unable to open file: %s, error: %v", saveFilePath, err)
 		return nil, err

server/client-messages.go

@@ -165,36 +165,6 @@ 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
@@ -310,34 +280,3 @@ 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

@@ -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", secType)
+		return fmt.Errorf("server type %d not implemented")
 	}
 
 	var authCode uint32
@@ -135,7 +135,7 @@ func ServerServerInitHandler(cfg *ServerConfig, c *ServerConn) error {
 		NameLength:  uint32(len(cfg.DesktopName)),
 		NameText:    []byte(cfg.DesktopName),
 	}
-	logger.Debugf("Server.ServerServerInitHandler initMessage: %v", srvInit)
+	logger.Infof("Server.ServerServerInitHandler initMessage: %v", srvInit)
 	if err := binary.Write(c, binary.BigEndian, srvInit.FBWidth); err != nil {
 		return err
 	}

server/server-conn.go

@@ -168,28 +168,73 @@ func (c *ServerConn) handle() error {
 		default:
 			var messageType common.ClientMessageType
 			if err := binary.Read(c, binary.BigEndian, &messageType); err != nil {
-				logger.Errorf("ServerConn.handle error: %v", err)
+				logger.Errorf("IServerConn.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 {
-				logger.Errorf("ServerConn.handle: unsupported message-type: %v", messageType)
+				return fmt.Errorf("IServerConn.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:
 				// update pixel format
-				logger.Debugf("ClientUpdater.Consume: updating pixel format")
+				logger.Debugf("IServerConn.Handle: updating pixel format")
 				pixFmtMsg := parsedMsg.(*MsgSetPixelFormat)
 				c.SetPixelFormat(&pixFmtMsg.PF)
 				if pixFmtMsg.PF.TrueColor != 0 {
 					c.SetColorMap(&common.ColorMap{})
 				}
+
+			case common.FramebufferUpdateRequestMsgType:
+				//logger.Infof("IServerConn.Handle:  msgBuff update request")
+				//updMsg := parsedMsg.(*MsgFramebufferUpdateRequest)
+				//updMsg.Inc = 1
+			case common.SetEncodingsMsgType:
+				encMsg := parsedMsg.(*MsgSetEncodings)
+				// for i, enc := range encMsg.Encodings {
+				// 	if enc > common.EncJPEGQualityLevelPseudo1 && enc < common.EncJPEGQualityLevelPseudo10 { //common.EncCursorPseudo
+				// 		//encMsg.EncNum--
+				// 		//encMsg.Encodings = append(encMsg.Encodings[:i], encMsg.Encodings[i+1:]...)
+				// 		encMsg.Encodings[i] = encMsg.Encodings[len(encMsg.Encodings)-1]
+				// 		encMsg.Encodings[len(encMsg.Encodings)-1] = common.EncJPEGQualityLevelPseudo9
+				// 		break
+				// 	}
+				// 	// if enc == common.EncCompressionLevel3 {
+				// 	// 	encMsg.Encodings[i] = common.EncJPEGQualityLevelPseudo9
+				// 	// }
+				// 	// if enc == common.EncJPEGQualityLevelPseudo7 {
+				// 	// 	encMsg.Encodings[i] = common.EncJPEGQualityLevelPseudo9
+				// 	// }
+				// }
+
+				encMsg.Encodings = []common.EncodingType{
+					common.EncDesktopSizePseudo,
+					common.EncExtendedDesktopSizePseudo,
+					common.EncLastRectPseudo,
+					common.EncContinuousUpdatesPseudo,
+					common.EncCursorPseudo,
+					common.EncFencePseudo,
+					common.EncHextile,
+					common.EncCopyRect,
+					common.EncTight,
+					common.EncZRLE,
+					common.EncRRE,
+					common.EncRaw,
+					common.EncCompressionLevel2,
+					common.EncJPEGQualityLevelPseudo1,
+					common.EncQEMUExtendedKeyEventPseudo,
+					common.EncTightPng,
+					common.EncXvpPseudo,
+				}
+				encMsg.EncNum = uint16(len(encMsg.Encodings))
+
+				//bad: EncCopyRect EncTight EncTightPng EncHextile EncRRE EncRaw EncJPEGQualityLevelPseudo7 EncCompressionLevel3 EncDesktopSizePseudo EncLastRectPseudo EncCursorPseudo EncQEMUExtendedKeyEventPseudo EncExtendedDesktopSizePseudo EncXvpPseudo EncFencePseudo EncContinuousUpdatesPseudo
 			}
+
 			////////
 
 			if err != nil {
@@ -197,7 +242,7 @@ func (c *ServerConn) handle() error {
 				return err
 			}
 
-			logger.Debugf("IServerConn.Handle got ClientMessage: %s, %v", parsedMsg.Type(), parsedMsg)
+			logger.Infof("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

@@ -15,7 +15,6 @@ var DefaultClientMessages = []common.ClientMessage{
 	&MsgKeyEvent{},
 	&MsgPointerEvent{},
 	&MsgClientCutText{},
-	&MsgClientQemuExtendedKey{},
 }
 
 // FramebufferUpdate holds a FramebufferUpdate wire format message.