FrameBuffer proto working

Makefile

@@ -5,4 +5,5 @@ run_rec:
 	./bin/vnc_recorder -recDir=./bin/recordings/ -logLevel=debug -targHost=localhost -targPort=5901 -targPass=boxware -tcpPort=5902 -vncPass=boxware
 
 clear:
-	rm -rf bin/recordings/*
+	rm -rf bin/recordings/*
+	rm -rf output.txt

client/server-messages.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"strings"
+
 	"github.com/amitbet/vncproxy/common"
 	"github.com/amitbet/vncproxy/encodings"
 	"github.com/amitbet/vncproxy/logger"

proto/demo.pb.go

@@ -28,6 +28,7 @@ type InitMsg struct {
 	SecType              uint32   `protobuf:"varint,5,opt,name=SecType,json=secType,proto3" json:"SecType,omitempty"`
 	StartTime            uint32   `protobuf:"varint,6,opt,name=StartTime,json=startTime,proto3" json:"StartTime,omitempty"`
 	DesktopName          string   `protobuf:"bytes,7,opt,name=DesktopName,json=desktopName,proto3" json:"DesktopName,omitempty"`
+	PixelFormat          string   `protobuf:"bytes,8,opt,name=PixelFormat,json=pixelFormat,proto3" json:"PixelFormat,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -107,6 +108,13 @@ func (m *InitMsg) GetDesktopName() string {
 	return ""
 }
 
+func (m *InitMsg) GetPixelFormat() string {
+	if m != nil {
+		return m.PixelFormat
+	}
+	return ""
+}
+
 type PointerEvent struct {
 	Mask                 uint32   `protobuf:"varint,1,opt,name=Mask,json=mask,proto3" json:"Mask,omitempty"`
 	X                    uint32   `protobuf:"varint,2,opt,name=X,json=x,proto3" json:"X,omitempty"`
@@ -272,21 +280,259 @@ func (m *FbsSegment) GetTimestamp() uint32 {
 	return 0
 }
 
+type PixelFormat struct {
+	BPP                  uint32   `protobuf:"varint,1,opt,name=BPP,json=bPP,proto3" json:"BPP,omitempty"`
+	Depth                uint32   `protobuf:"varint,2,opt,name=Depth,json=depth,proto3" json:"Depth,omitempty"`
+	BigEndian            uint32   `protobuf:"varint,3,opt,name=BigEndian,json=bigEndian,proto3" json:"BigEndian,omitempty"`
+	TrueColor            uint32   `protobuf:"varint,4,opt,name=TrueColor,json=trueColor,proto3" json:"TrueColor,omitempty"`
+	RedMax               uint32   `protobuf:"varint,5,opt,name=RedMax,json=redMax,proto3" json:"RedMax,omitempty"`
+	GreenMax             uint32   `protobuf:"varint,6,opt,name=GreenMax,json=greenMax,proto3" json:"GreenMax,omitempty"`
+	BlueMax              uint32   `protobuf:"varint,7,opt,name=BlueMax,json=blueMax,proto3" json:"BlueMax,omitempty"`
+	RedShift             uint32   `protobuf:"varint,8,opt,name=RedShift,json=redShift,proto3" json:"RedShift,omitempty"`
+	GreenShift           uint32   `protobuf:"varint,9,opt,name=GreenShift,json=greenShift,proto3" json:"GreenShift,omitempty"`
+	BlueShift            uint32   `protobuf:"varint,10,opt,name=BlueShift,json=blueShift,proto3" json:"BlueShift,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *PixelFormat) Reset()         { *m = PixelFormat{} }
+func (m *PixelFormat) String() string { return proto.CompactTextString(m) }
+func (*PixelFormat) ProtoMessage()    {}
+func (*PixelFormat) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ca53982754088a9d, []int{4}
+}
+
+func (m *PixelFormat) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_PixelFormat.Unmarshal(m, b)
+}
+func (m *PixelFormat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_PixelFormat.Marshal(b, m, deterministic)
+}
+func (m *PixelFormat) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_PixelFormat.Merge(m, src)
+}
+func (m *PixelFormat) XXX_Size() int {
+	return xxx_messageInfo_PixelFormat.Size(m)
+}
+func (m *PixelFormat) XXX_DiscardUnknown() {
+	xxx_messageInfo_PixelFormat.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PixelFormat proto.InternalMessageInfo
+
+func (m *PixelFormat) GetBPP() uint32 {
+	if m != nil {
+		return m.BPP
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetDepth() uint32 {
+	if m != nil {
+		return m.Depth
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetBigEndian() uint32 {
+	if m != nil {
+		return m.BigEndian
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetTrueColor() uint32 {
+	if m != nil {
+		return m.TrueColor
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetRedMax() uint32 {
+	if m != nil {
+		return m.RedMax
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetGreenMax() uint32 {
+	if m != nil {
+		return m.GreenMax
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetBlueMax() uint32 {
+	if m != nil {
+		return m.BlueMax
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetRedShift() uint32 {
+	if m != nil {
+		return m.RedShift
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetGreenShift() uint32 {
+	if m != nil {
+		return m.GreenShift
+	}
+	return 0
+}
+
+func (m *PixelFormat) GetBlueShift() uint32 {
+	if m != nil {
+		return m.BlueShift
+	}
+	return 0
+}
+
+type Rectangle struct {
+	X                    uint32   `protobuf:"varint,1,opt,name=X,json=x,proto3" json:"X,omitempty"`
+	Y                    uint32   `protobuf:"varint,2,opt,name=Y,json=y,proto3" json:"Y,omitempty"`
+	Width                uint32   `protobuf:"varint,3,opt,name=Width,json=width,proto3" json:"Width,omitempty"`
+	Height               uint32   `protobuf:"varint,4,opt,name=Height,json=height,proto3" json:"Height,omitempty"`
+	Enc                  uint32   `protobuf:"varint,5,opt,name=Enc,json=enc,proto3" json:"Enc,omitempty"`
+	Bytes                []byte   `protobuf:"bytes,6,opt,name=Bytes,json=bytes,proto3" json:"Bytes,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Rectangle) Reset()         { *m = Rectangle{} }
+func (m *Rectangle) String() string { return proto.CompactTextString(m) }
+func (*Rectangle) ProtoMessage()    {}
+func (*Rectangle) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ca53982754088a9d, []int{5}
+}
+
+func (m *Rectangle) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Rectangle.Unmarshal(m, b)
+}
+func (m *Rectangle) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Rectangle.Marshal(b, m, deterministic)
+}
+func (m *Rectangle) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Rectangle.Merge(m, src)
+}
+func (m *Rectangle) XXX_Size() int {
+	return xxx_messageInfo_Rectangle.Size(m)
+}
+func (m *Rectangle) XXX_DiscardUnknown() {
+	xxx_messageInfo_Rectangle.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Rectangle proto.InternalMessageInfo
+
+func (m *Rectangle) GetX() uint32 {
+	if m != nil {
+		return m.X
+	}
+	return 0
+}
+
+func (m *Rectangle) GetY() uint32 {
+	if m != nil {
+		return m.Y
+	}
+	return 0
+}
+
+func (m *Rectangle) GetWidth() uint32 {
+	if m != nil {
+		return m.Width
+	}
+	return 0
+}
+
+func (m *Rectangle) GetHeight() uint32 {
+	if m != nil {
+		return m.Height
+	}
+	return 0
+}
+
+func (m *Rectangle) GetEnc() uint32 {
+	if m != nil {
+		return m.Enc
+	}
+	return 0
+}
+
+func (m *Rectangle) GetBytes() []byte {
+	if m != nil {
+		return m.Bytes
+	}
+	return nil
+}
+
+type FramebufferUpdate struct {
+	Rectangles           []*Rectangle `protobuf:"bytes,1,rep,name=rectangles,proto3" json:"rectangles,omitempty"`
+	Timestamp            uint32       `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *FramebufferUpdate) Reset()         { *m = FramebufferUpdate{} }
+func (m *FramebufferUpdate) String() string { return proto.CompactTextString(m) }
+func (*FramebufferUpdate) ProtoMessage()    {}
+func (*FramebufferUpdate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_ca53982754088a9d, []int{6}
+}
+
+func (m *FramebufferUpdate) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FramebufferUpdate.Unmarshal(m, b)
+}
+func (m *FramebufferUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FramebufferUpdate.Marshal(b, m, deterministic)
+}
+func (m *FramebufferUpdate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FramebufferUpdate.Merge(m, src)
+}
+func (m *FramebufferUpdate) XXX_Size() int {
+	return xxx_messageInfo_FramebufferUpdate.Size(m)
+}
+func (m *FramebufferUpdate) XXX_DiscardUnknown() {
+	xxx_messageInfo_FramebufferUpdate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FramebufferUpdate proto.InternalMessageInfo
+
+func (m *FramebufferUpdate) GetRectangles() []*Rectangle {
+	if m != nil {
+		return m.Rectangles
+	}
+	return nil
+}
+
+func (m *FramebufferUpdate) GetTimestamp() uint32 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
 type Demonstration struct {
-	Initmsg              *InitMsg        `protobuf:"bytes,1,opt,name=initmsg,proto3" json:"initmsg,omitempty"`
-	Segments             []*FbsSegment   `protobuf:"bytes,2,rep,name=segments,proto3" json:"segments,omitempty"`
-	Pointerevents        []*PointerEvent `protobuf:"bytes,3,rep,name=pointerevents,proto3" json:"pointerevents,omitempty"`
-	Keyevents            []*KeyEvent     `protobuf:"bytes,4,rep,name=keyevents,proto3" json:"keyevents,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
+	Initmsg              *InitMsg             `protobuf:"bytes,1,opt,name=initmsg,proto3" json:"initmsg,omitempty"`
+	Fbupdates            []*FramebufferUpdate `protobuf:"bytes,2,rep,name=fbupdates,proto3" json:"fbupdates,omitempty"`
+	Segments             []*FbsSegment        `protobuf:"bytes,3,rep,name=segments,proto3" json:"segments,omitempty"`
+	Pointerevents        []*PointerEvent      `protobuf:"bytes,4,rep,name=pointerevents,proto3" json:"pointerevents,omitempty"`
+	Keyevents            []*KeyEvent          `protobuf:"bytes,5,rep,name=keyevents,proto3" json:"keyevents,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
 }
 
 func (m *Demonstration) Reset()         { *m = Demonstration{} }
 func (m *Demonstration) String() string { return proto.CompactTextString(m) }
 func (*Demonstration) ProtoMessage()    {}
 func (*Demonstration) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ca53982754088a9d, []int{4}
+	return fileDescriptor_ca53982754088a9d, []int{7}
 }
 
 func (m *Demonstration) XXX_Unmarshal(b []byte) error {
@@ -314,6 +560,13 @@ func (m *Demonstration) GetInitmsg() *InitMsg {
 	return nil
 }
 
+func (m *Demonstration) GetFbupdates() []*FramebufferUpdate {
+	if m != nil {
+		return m.Fbupdates
+	}
+	return nil
+}
+
 func (m *Demonstration) GetSegments() []*FbsSegment {
 	if m != nil {
 		return m.Segments
@@ -340,37 +593,56 @@ func init() {
 	proto.RegisterType((*PointerEvent)(nil), "proto.PointerEvent")
 	proto.RegisterType((*KeyEvent)(nil), "proto.KeyEvent")
 	proto.RegisterType((*FbsSegment)(nil), "proto.FbsSegment")
+	proto.RegisterType((*PixelFormat)(nil), "proto.PixelFormat")
+	proto.RegisterType((*Rectangle)(nil), "proto.Rectangle")
+	proto.RegisterType((*FramebufferUpdate)(nil), "proto.FramebufferUpdate")
 	proto.RegisterType((*Demonstration)(nil), "proto.Demonstration")
 }
 
 func init() { proto.RegisterFile("demo.proto", fileDescriptor_ca53982754088a9d) }
 
 var fileDescriptor_ca53982754088a9d = []byte{
-	// 408 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x91, 0x4f, 0x8b, 0xdb, 0x30,
-	0x10, 0xc5, 0x51, 0x9c, 0xac, 0xe3, 0x49, 0xdc, 0x3f, 0x6a, 0x0f, 0xa2, 0x94, 0x12, 0x72, 0xca,
-	0x65, 0xf7, 0xb0, 0x3d, 0xf5, 0x56, 0x96, 0x34, 0x6c, 0x59, 0x76, 0x29, 0xca, 0xd2, 0x3f, 0xd0,
-	0x8b, 0x5d, 0x8f, 0xbd, 0xc2, 0x48, 0x32, 0x92, 0xd8, 0xad, 0xbf, 0x66, 0x2f, 0xfd, 0x3a, 0xc5,
-	0xb2, 0x1c, 0x37, 0x39, 0x99, 0x99, 0x37, 0xef, 0xe7, 0xa7, 0x19, 0x80, 0x02, 0xa5, 0xbe, 0x68,
-	0x8c, 0x76, 0x9a, 0xce, 0xfc, 0x67, 0xfd, 0x97, 0x40, 0xfc, 0x59, 0x09, 0x77, 0x6b, 0x2b, 0xfa,
-	0x16, 0x12, 0x5e, 0xe6, 0xd7, 0x98, 0x15, 0x68, 0x18, 0x59, 0x91, 0x4d, 0xc2, 0x13, 0x33, 0x34,
-	0xe8, 0x3b, 0x00, 0x5e, 0xe6, 0x5f, 0xd1, 0x58, 0xa1, 0x15, 0x9b, 0x78, 0x19, 0xcc, 0xa1, 0x43,
-	0xdf, 0xc0, 0x7c, 0x77, 0x75, 0x8d, 0xa2, 0x7a, 0x70, 0x2c, 0x5a, 0x91, 0x4d, 0xca, 0xe7, 0x65,
-	0xa8, 0x29, 0x83, 0x78, 0x77, 0xf5, 0x4d, 0x14, 0xee, 0x81, 0x4d, 0xbd, 0x14, 0x97, 0x7d, 0xd9,
-	0x29, 0x7b, 0xfc, 0x75, 0xdf, 0x36, 0xc8, 0x66, 0xbd, 0x62, 0xfb, 0xb2, 0x4b, 0xb3, 0x77, 0x99,
-	0x71, 0xf7, 0x42, 0x22, 0x3b, 0xf3, 0x5a, 0x62, 0x87, 0x06, 0x5d, 0xc1, 0x62, 0x8b, 0xb6, 0x76,
-	0xba, 0xb9, 0xcb, 0x24, 0xb2, 0xd8, 0xc7, 0x59, 0x14, 0x63, 0x6b, 0xfd, 0x13, 0x96, 0x5f, 0xb4,
-	0x50, 0x0e, 0xcd, 0xa7, 0x47, 0x54, 0x8e, 0x52, 0x98, 0xde, 0x66, 0xb6, 0xf6, 0x0f, 0x4b, 0xf9,
-	0x54, 0x66, 0xb6, 0xa6, 0x4b, 0x20, 0xdf, 0xfd, 0x53, 0x52, 0x4e, 0x7e, 0x77, 0xd5, 0x8f, 0x10,
-	0x9d, 0xb4, 0xdd, 0xff, 0x9d, 0x90, 0x68, 0x5d, 0x26, 0x9b, 0x90, 0x7a, 0x6c, 0xac, 0xef, 0x60,
-	0x7e, 0x83, 0xed, 0x81, 0xbc, 0xd5, 0x4f, 0x6a, 0x20, 0x17, 0xfa, 0x49, 0xd1, 0x17, 0x10, 0xdd,
-	0x60, 0x1b, 0xd8, 0x51, 0x8d, 0x27, 0xbc, 0xe8, 0x94, 0xf7, 0x11, 0x60, 0x97, 0xdb, 0x3d, 0x56,
-	0xb2, 0x23, 0xbe, 0x86, 0x59, 0xde, 0x3a, 0xb4, 0x1e, 0xb9, 0xe4, 0x7d, 0x71, 0x4c, 0x98, 0x9c,
-	0x12, 0xfe, 0x10, 0x48, 0xb7, 0x28, 0xb5, 0xb2, 0xce, 0x64, 0xae, 0xbb, 0xc8, 0x06, 0x62, 0xa1,
-	0x84, 0x93, 0xb6, 0xf2, 0x9c, 0xc5, 0xe5, 0xb3, 0xfe, 0xf6, 0x17, 0xe1, 0xe0, 0x7c, 0x90, 0xe9,
-	0x39, 0xcc, 0x6d, 0xff, 0x6b, 0xcb, 0x26, 0xab, 0x68, 0xb3, 0xb8, 0x7c, 0x19, 0x46, 0xc7, 0x50,
-	0xfc, 0x30, 0x42, 0x3f, 0x40, 0xda, 0xf4, 0xab, 0xc5, 0x47, 0xef, 0x89, 0xbc, 0xe7, 0x55, 0xf0,
-	0xfc, 0xbf, 0x76, 0x7e, 0x3c, 0x49, 0xcf, 0x21, 0xa9, 0xb1, 0x0d, 0xb6, 0xa9, 0xb7, 0x3d, 0x0f,
-	0xb6, 0x61, 0x9f, 0x7c, 0x9c, 0xc8, 0xcf, 0xbc, 0xf4, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0xaa, 0x99, 0xea, 0x8d, 0xba, 0x02, 0x00, 0x00,
+	// 663 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x54, 0x4d, 0x6b, 0xdb, 0x5a,
+	0x10, 0x45, 0x96, 0x25, 0x4b, 0xe3, 0xf8, 0xbd, 0xe4, 0xbe, 0x10, 0xc4, 0xe3, 0xf1, 0x08, 0x5e,
+	0x79, 0x93, 0x50, 0x52, 0x28, 0x74, 0x57, 0x5c, 0xc7, 0x4d, 0x09, 0x09, 0xe6, 0x3a, 0xfd, 0x82,
+	0x6e, 0x24, 0x6b, 0x24, 0x0b, 0x5b, 0x57, 0xe2, 0xde, 0xeb, 0x24, 0x5e, 0xf4, 0x0f, 0xf4, 0x1f,
+	0xf4, 0xa7, 0x76, 0x57, 0xee, 0x87, 0xe4, 0x38, 0x5d, 0x74, 0x25, 0x66, 0xce, 0x9c, 0xc3, 0x99,
+	0x3b, 0x33, 0x02, 0x48, 0xb1, 0xac, 0xce, 0x6b, 0x5e, 0xc9, 0x8a, 0x78, 0xfa, 0x33, 0xfc, 0xe9,
+	0x40, 0xef, 0x3d, 0x2b, 0xe4, 0x8d, 0xc8, 0xc9, 0x7f, 0x10, 0xd2, 0x2c, 0xb9, 0xc2, 0x38, 0x45,
+	0x1e, 0x39, 0xa7, 0xce, 0x28, 0xa4, 0x21, 0x6f, 0x12, 0xe4, 0x7f, 0x00, 0x9a, 0x25, 0x1f, 0x91,
+	0x8b, 0xa2, 0x62, 0x51, 0x47, 0xc3, 0xc0, 0xdb, 0x0c, 0xf9, 0x17, 0x82, 0xe9, 0xf8, 0x0a, 0x8b,
+	0x7c, 0x29, 0x23, 0xf7, 0xd4, 0x19, 0x0d, 0x68, 0x90, 0xd9, 0x98, 0x44, 0xd0, 0x9b, 0x8e, 0x3f,
+	0x15, 0xa9, 0x5c, 0x46, 0x5d, 0x0d, 0xf5, 0x32, 0x13, 0x2a, 0x64, 0x8e, 0x8b, 0xbb, 0x6d, 0x8d,
+	0x91, 0x67, 0x10, 0x61, 0x42, 0xe5, 0x66, 0x2e, 0x63, 0x2e, 0xef, 0x8a, 0x12, 0x23, 0x5f, 0x63,
+	0xa1, 0x68, 0x12, 0xe4, 0x14, 0xfa, 0x13, 0x14, 0x2b, 0x59, 0xd5, 0xb7, 0x71, 0x89, 0x51, 0x4f,
+	0xdb, 0xe9, 0xa7, 0xbb, 0x94, 0xaa, 0x98, 0x15, 0x8f, 0xb8, 0x9e, 0x56, 0xbc, 0x8c, 0x65, 0x14,
+	0x98, 0x8a, 0x7a, 0x97, 0x1a, 0x7e, 0x85, 0x83, 0x59, 0x55, 0x30, 0x89, 0xfc, 0xf2, 0x1e, 0x99,
+	0x24, 0x04, 0xba, 0x37, 0xb1, 0x58, 0xe9, 0xd6, 0x07, 0xb4, 0x5b, 0xc6, 0x62, 0x45, 0x0e, 0xc0,
+	0xf9, 0xac, 0x9b, 0x1d, 0x50, 0xe7, 0x51, 0x45, 0x5f, 0x6c, 0x73, 0xce, 0x56, 0x39, 0x94, 0x45,
+	0x89, 0x42, 0xc6, 0x65, 0x6d, 0xfb, 0xda, 0x25, 0x86, 0xb7, 0x10, 0x5c, 0xe3, 0xb6, 0x55, 0x9e,
+	0x54, 0x0f, 0xac, 0x51, 0x4e, 0xab, 0x07, 0x46, 0x0e, 0xc1, 0xbd, 0xc6, 0xad, 0xd5, 0x76, 0x57,
+	0xf8, 0x4c, 0xcf, 0x7d, 0xae, 0xf7, 0x06, 0x60, 0x9a, 0x88, 0x39, 0xe6, 0xa5, 0x52, 0x3c, 0x06,
+	0x2f, 0xd9, 0x4a, 0x14, 0x5a, 0xf2, 0x80, 0x9a, 0x60, 0x5f, 0xa1, 0xf3, 0x5c, 0xe1, 0x47, 0x67,
+	0xef, 0x49, 0x94, 0x83, 0xf1, 0x6c, 0x66, 0x4d, 0xb9, 0xc9, 0x6c, 0xa6, 0x54, 0x27, 0x58, 0xcb,
+	0xa5, 0xe5, 0x7a, 0xa9, 0x0a, 0x94, 0xea, 0xb8, 0xc8, 0x2f, 0x59, 0x5a, 0xc4, 0xac, 0xf1, 0x95,
+	0x34, 0x09, 0x85, 0xde, 0xf1, 0x0d, 0xbe, 0xad, 0xd6, 0x15, 0x6f, 0x5f, 0xa1, 0x49, 0x90, 0x13,
+	0xf0, 0x29, 0xa6, 0x37, 0xf1, 0xa3, 0x1d, 0xaf, 0xcf, 0x75, 0xa4, 0xb6, 0xe5, 0x1d, 0x47, 0x64,
+	0x0a, 0x31, 0xc3, 0x0d, 0x72, 0x1b, 0xab, 0x9d, 0x18, 0xaf, 0x37, 0xa8, 0xa0, 0x9e, 0xd9, 0x89,
+	0xc4, 0x84, 0x8a, 0x45, 0x31, 0x9d, 0x2f, 0x8b, 0xcc, 0x0c, 0x74, 0x40, 0x03, 0x6e, 0x63, 0xb5,
+	0x9f, 0x5a, 0xd1, 0xa0, 0xa1, 0x46, 0x21, 0x6f, 0x33, 0xba, 0x8b, 0xf5, 0x06, 0x0d, 0x0c, 0xb6,
+	0x8b, 0x26, 0x31, 0xfc, 0x06, 0x21, 0xc5, 0x85, 0x8c, 0x59, 0xbe, 0x46, 0x33, 0x74, 0x67, 0x6f,
+	0xe8, 0x9d, 0x66, 0xe8, 0xc7, 0xe0, 0x99, 0x45, 0x36, 0x0f, 0xe1, 0x3d, 0xe8, 0x35, 0x3e, 0x01,
+	0xdf, 0xae, 0xbe, 0x79, 0x01, 0x7f, 0x69, 0x16, 0xff, 0x10, 0xdc, 0x4b, 0xb6, 0xb0, 0xbd, 0xbb,
+	0xc8, 0x16, 0x8a, 0x3f, 0xd6, 0x83, 0xf3, 0x9f, 0x0c, 0x6e, 0xb8, 0x80, 0xa3, 0x29, 0x8f, 0x4b,
+	0x4c, 0x36, 0x59, 0x86, 0xfc, 0x43, 0x9d, 0xc6, 0x12, 0xc9, 0x0b, 0x00, 0xde, 0x78, 0x52, 0x83,
+	0x76, 0x47, 0xfd, 0x8b, 0x43, 0x73, 0xbe, 0xe7, 0xad, 0x59, 0xfa, 0xa4, 0xe6, 0x0f, 0xf3, 0xff,
+	0xde, 0x81, 0xc1, 0x04, 0xcb, 0x8a, 0x09, 0xc9, 0x63, 0xa9, 0x6e, 0x76, 0x04, 0xbd, 0x82, 0x15,
+	0xb2, 0x14, 0xb9, 0x6e, 0xb7, 0x7f, 0xf1, 0x97, 0x95, 0xb7, 0xbf, 0x04, 0xda, 0xc0, 0xe4, 0x15,
+	0x84, 0x59, 0xb2, 0xd1, 0xbe, 0x44, 0xd4, 0xd1, 0x56, 0x22, 0x5b, 0xfb, 0x9b, 0x71, 0xba, 0x2b,
+	0x25, 0x67, 0x10, 0x08, 0xb3, 0xb2, 0x22, 0x72, 0x35, 0xed, 0xa8, 0xa1, 0xb5, 0xcb, 0x4c, 0xdb,
+	0x12, 0xf2, 0x1a, 0x06, 0xb5, 0x39, 0x49, 0xbc, 0xd7, 0x9c, 0xae, 0xe6, 0xfc, 0x63, 0x39, 0x4f,
+	0xcf, 0x95, 0xee, 0x57, 0x92, 0x33, 0x08, 0x57, 0xb8, 0xb5, 0x34, 0x4f, 0xd3, 0xfe, 0xb6, 0xb4,
+	0xe6, 0x0e, 0xe9, 0xae, 0x22, 0xf1, 0x35, 0xf4, 0xf2, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x41,
+	0x67, 0x4d, 0x1f, 0x14, 0x05, 0x00, 0x00,
 }

proto/demo.proto

@@ -9,6 +9,7 @@ message InitMsg {
     uint32 SecType = 5;
     uint32 StartTime = 6;
     string DesktopName = 7;
+    string PixelFormat = 8;
 }
 
 message PointerEvent {
@@ -30,9 +31,37 @@ message FbsSegment{
     uint32 timestamp = 2;
 }
 
+message PixelFormat{
+    uint32 BPP = 1;
+	uint32 Depth = 2;
+	uint32 BigEndian = 3;
+	uint32 TrueColor = 4;
+	uint32 RedMax = 5;
+	uint32 GreenMax = 6;
+    uint32 BlueMax = 7;
+	uint32 RedShift = 8;
+	uint32 GreenShift = 9;
+	uint32 BlueShift = 10; 
+}
+
+message Rectangle {
+    uint32 X = 1;
+    uint32 Y = 2;
+    uint32 Width = 3;
+    uint32 Height = 4;
+    uint32 Enc = 5;
+    bytes Bytes = 6;
+}
+
+message FramebufferUpdate{
+    repeated Rectangle rectangles = 1;
+    uint32 timestamp = 2;
+}
+
 message Demonstration {
     InitMsg initmsg = 1;
-    repeated FbsSegment segments = 2;
-    repeated PointerEvent pointerevents = 3;
-    repeated KeyEvent keyevents = 4;
+    repeated FramebufferUpdate fbupdates = 2;
+    repeated FbsSegment segments = 3;
+    repeated PointerEvent pointerevents = 4;
+    repeated KeyEvent keyevents = 5;
 }

vnc_read/main.go

@@ -43,11 +43,45 @@ func listPeople(w io.Writer, demo *pb.Demonstration) {
 	fmt.Printf("DesktopName: %v \n", demo.Initmsg.GetDesktopName())
 
 	// for _, p := range demo.Segments {
-	// 	writePerson(w, p)
+	// 	writeSegment(w, p)
 	// }
+
+	// for _, k := range demo.Keyevents {
+	// 	writeKeyEvent(w, k)
+	// }
+
+	// for _, p := range demo.Pointerevents {
+	// 	writePointerEvent(w, p)
+	// }
+
+	for _, p := range demo.Fbupdates {
+		fmt.Print(p)
+	}
+
 }
 
-func writePerson(w io.Writer, p *pb.FbsSegment) {
+func writeSegment(w io.Writer, p *pb.FbsSegment) {
 	fmt.Printf("Length: %v Timestamp: %v \n", len(p.GetBytes()), p.GetTimestamp())
 
 }
+
+func writeFbupdate(w io.Writer, p *pb.FramebufferUpdate) {
+
+	for _, r := range p.Rectangles {
+		fmt.Printf("(%d,%d) (width: %d, height: %d), Enc= %d \n", r.X, r.Y, r.Width, r.Height, r.Enc)
+
+	}
+
+}
+
+func writeKeyEvent(w io.Writer, p *pb.KeyEvent) {
+
+	fmt.Printf(" KeyEvent : Down : %v, Key: %v) \n", p.GetDown(), p.GetKey())
+
+}
+
+func writePointerEvent(w io.Writer, p *pb.PointerEvent) {
+
+	fmt.Printf(" PointerEvent : X : %v, Y: %v , Mask: %v \n", p.GetX(), p.GetY(), p.GetMask())
+
+}

vnc_rec/proto-recorder.go

@@ -2,6 +2,7 @@ package vnc_rec
 
 import (
 	"bytes"
+	"encoding/binary"
 	"fmt"
 	"io/ioutil"
 	"log"
@@ -20,6 +21,9 @@ type ProtoRecorder struct {
 	writer        *os.File
 	demonstration *pb.Demonstration
 	//logger              common.Logger
+	Rectbuffer          bytes.Buffer
+	FramebufferUpdate   *pb.FramebufferUpdate
+	Rect                *pb.Rectangle
 	startTime           int
 	buffer              bytes.Buffer
 	serverInitMessage   *common.ServerInit
@@ -149,6 +153,39 @@ func (r *ProtoRecorder) HandleRfbSegment(data *common.RfbSegment) error {
 		switch common.ServerMessageType(data.UpcomingObjectType) {
 		case common.FramebufferUpdate:
 			logger.Debugf("ProtoRecorder.HandleRfbSegment: saving FramebufferUpdate segment")
+			//FBUpdate := data.Message.(*server.FramebufferUpdate)
+			if len(r.FramebufferUpdate.GetRectangles()) != 0 {
+				logger.Debugf("[IMP STUFF] Nil not found, now appending")
+				r.demonstration.Fbupdates = append(r.demonstration.Fbupdates, r.FramebufferUpdate)
+
+			}
+			logger.Debugf("[IMPORTANT] This FrameBufferUpdate is: %v", data.Bytes)
+
+			logger.Debugf("The FrameBuffer is: %v", r.FramebufferUpdate)
+
+			//r.FramebufferUpdate.Reset()
+
+			r.FramebufferUpdate = &pb.FramebufferUpdate{
+				Timestamp: timeSinceStart,
+			}
+
+			// FBUpdateProto := &pb.FramebufferUpdate{}
+
+			// for _, rect := range FBUpdate.Rects {
+
+			// 	RectProto := &pb.Rectangle{
+			// 		X:      uint32(rect.X),
+			// 		Y:      uint32(rect.Y),
+			// 		Width:  uint32(rect.Width),
+			// 		Height: uint32(rect.Height),
+			// 		Enc:    uint32(rect.Enc.Type()),
+			// 	}
+
+			// 	FBUpdateProto.Rectangles = append(FBUpdateProto.Rectangles, RectProto)
+			// }
+
+			// r.demonstration.Fbupdates = append(r.demonstration.Fbupdates, FBUpdateProto)
+
 			//r.writeToDisk()
 		case common.SetColourMapEntries:
 		case common.Bell:
@@ -160,18 +197,45 @@ func (r *ProtoRecorder) HandleRfbSegment(data *common.RfbSegment) error {
 		r.writeToDisk()
 	case common.SegmentRectSeparator:
 		logger.Debugf("ProtoRecorder.HandleRfbSegment: writing rect")
+		//r.Rect.Reset()
 		//r.writeToDisk()
 	case common.SegmentBytes:
 		logger.Debug("ProtoRecorder.HandleRfbSegment: writing bytes, len:", len(data.Bytes))
 		// if r.buffer.Len()+len(data.Bytes) > r.maxWriteSize-4 {
 		// 	r.writeToDisk()
 		// }
-		segment := &pb.FbsSegment{
-			Bytes:     data.Bytes,
-			Timestamp: timeSinceStart,
+
+		if len(data.Bytes) > 4 {
+
+			idx := r.Rectbuffer.Len() - 16
+			p := make([]byte, idx)
+			r.Rectbuffer.Read(p)
+			main := make([]byte, 16)
+			r.Rectbuffer.Read(main)
+			r.Rect = &pb.Rectangle{
+				X:      uint32(binary.BigEndian.Uint16(main[:2])),
+				Y:      uint32(binary.BigEndian.Uint16(main[2:4])),
+				Width:  uint32(binary.BigEndian.Uint16(main[4:6])),
+				Height: uint32(binary.BigEndian.Uint16(main[6:8])),
+				Enc:    binary.BigEndian.Uint32(main[8:12]),
+				Bytes:  data.Bytes,
+			}
+			logger.Debugf("Received Main Pixel Buffer Content %v \n", r.Rect)
+			r.FramebufferUpdate.Rectangles = append(r.FramebufferUpdate.Rectangles, r.Rect)
+			r.Rectbuffer.Reset()
+		} else if len(data.Bytes) <= 4 {
+			logger.Debugf("Received Extra Short byte content %v , %v \n", len(data.Bytes), data.Bytes)
+			r.Rectbuffer.Write(data.Bytes)
+			// r.Rectbuffer = append(r.Rectbuffer, data.Bytes...)
+			//logger.Debugf("Rectbuffer currently is, %v", r.Rectbuffer)
 		}
 
-		r.demonstration.Segments = append(r.demonstration.Segments, segment)
+		// segment := &pb.FbsSegment{
+		// 	Bytes:     data.Bytes,
+		// 	Timestamp: timeSinceStart,
+		// }
+
+		// r.demonstration.Segments = append(r.demonstration.Segments, segment)
 		//_, err := r.buffer.Write(data.Bytes)
 		//return err
 	case common.SegmentServerInitMessage:
@@ -186,17 +250,18 @@ func (r *ProtoRecorder) HandleRfbSegment(data *common.RfbSegment) error {
 			r.serverInitMessage.PixelFormat = clientMsg.PF
 		case common.KeyEventMsgType:
 			clientMsg := data.Message.(*server.MsgKeyEvent)
-			logger.Debug("Recorder.HandleRfbSegment: writing bytes for KeyEventMsgType, len:", *clientMsg)
 			//clientMsg.Write(r.writer)
 			keyevent := &pb.KeyEvent{
 				Down:      uint32(clientMsg.Down),
 				Key:       uint32(clientMsg.Key),
 				Timestamp: timeSinceStart,
 			}
+			logger.Debug("ProtoRecorder.HandleRfbSegment: writing bytes for KeyEventMsgType, len:", *keyevent)
+
 			r.demonstration.Keyevents = append(r.demonstration.Keyevents, keyevent)
 		case common.PointerEventMsgType:
 			clientMsg := data.Message.(*server.MsgPointerEvent)
-			logger.Debug("Recorder.HandleRfbSegment: writing bytes for PointerEventMsgType, len:", *clientMsg)
+
 			//clientMsg.Write(r.writer)
 			pointerevent := &pb.PointerEvent{
 				Mask:      uint32(clientMsg.Mask),
@@ -204,6 +269,7 @@ func (r *ProtoRecorder) HandleRfbSegment(data *common.RfbSegment) error {
 				Y:         uint32(clientMsg.Y),
 				Timestamp: timeSinceStart,
 			}
+			logger.Debug("ProtoRecorder.HandleRfbSegment: writing bytes for PointerEventMsgType, len:", *pointerevent)
 			r.demonstration.Pointerevents = append(r.demonstration.Pointerevents, pointerevent)
 
 		default:

vnc_rec/proxy.go

@@ -79,33 +79,22 @@ func (vp *VncProxy) newServerConnHandler(cfg *server.ServerConfig, sconn *server
 		return err
 	}
 
-	var rec_s *ServerRecorder
-	var rec_c *ClientRecorder
+	//var rec_s *ServerRecorder
 	var rec_p *ProtoRecorder
 
 	if session.Type == SessionTypeRecordingProxy {
 		timeCurrent := strconv.FormatInt(time.Now().Unix(), 10)
 		recFolder := path.Join(vp.RecordingDir, "recording_"+timeCurrent)
 		os.MkdirAll(recFolder, os.ModePerm)
-		recServerFile := "server.rbs"
-		recServerPath := path.Join(recFolder, recServerFile)
-		rec_s, err = NewServerRecorder(recServerPath)
-		if err != nil {
-			logger.Errorf("Proxy.newServerConnHandler can't open ServerRecorder save path: %s", recServerPath)
-			return err
-		}
+		// recServerFile := "server.rbs"
+		// recServerPath := path.Join(recFolder, recServerFile)
+		// rec_s, err = NewServerRecorder(recServerPath)
+		// if err != nil {
+		// 	logger.Errorf("Proxy.newServerConnHandler can't open ServerRecorder save path: %s", recServerPath)
+		// 	return err
+		// }
 
-		sconn.Listeners.AddListener(rec_s)
-
-		recClientFile := "client.rbs"
-		recClientPath := path.Join(recFolder, recClientFile)
-		rec_c, err = NewClientRecorder(recClientPath)
-		if err != nil {
-			logger.Errorf("Proxy.newServerConnHandler can't open ClientRecorder save path: %s", recClientPath)
-			return err
-		}
-
-		sconn.Listeners.AddListener(rec_c)
+		// sconn.Listeners.AddListener(rec_s)
 
 		recProtoFile := "proto.rbs"
 		recProtoPath := path.Join(recFolder, recProtoFile)
@@ -132,8 +121,6 @@ func (vp *VncProxy) newServerConnHandler(cfg *server.ServerConfig, sconn *server
 			return err
 		}
 		if session.Type == SessionTypeRecordingProxy {
-			cconn.Listeners.AddListener(rec_s)
-			cconn.Listeners.AddListener(rec_c)
 			cconn.Listeners.AddListener(rec_p)
 		}