github.com/amitbet/vnc2video@v0.0.0-20190616012314-9d50b9dab1d9/messages_aten.go (about) 1 package vnc2video 2 3 import ( 4 "encoding/binary" 5 "fmt" 6 ) 7 8 // Aten IKVM server message types 9 const ( 10 AteniKVMFrontGroundEventMsgType ServerMessageType = 4 11 AteniKVMKeepAliveEventMsgType ServerMessageType = 22 12 AteniKVMVideoGetInfoMsgType ServerMessageType = 51 13 AteniKVMMouseGetInfoMsgType ServerMessageType = 55 14 AteniKVMSessionMessageMsgType ServerMessageType = 57 15 AteniKVMGetViewerLangMsgType ServerMessageType = 60 16 ) 17 18 // Aten IKVM client message types 19 const ( 20 AteniKVMKeyEventMsgType ClientMessageType = 4 21 AteniKVMPointerEventMsgType ClientMessageType = 5 22 ) 23 24 // AteniKVMKeyEvent holds the wire format message 25 type AteniKVMKeyEvent struct { 26 _ [1]byte // padding 27 Down uint8 // down-flag 28 _ [2]byte // padding 29 Key Key // key 30 _ [9]byte // padding 31 } 32 33 // AteniKVMPointerEvent holds the wire format message 34 type AteniKVMPointerEvent struct { 35 _ [1]byte // padding 36 Mask uint8 // mask 37 X uint16 // x 38 Y uint16 // y 39 _ [11]byte // padding 40 } 41 42 func (msg *AteniKVMPointerEvent) Supported(c Conn) bool { 43 return false 44 } 45 46 func (msg *AteniKVMPointerEvent) String() string { 47 return fmt.Sprintf("mask: %d, x:%d, y:%d", msg.Mask, msg.X, msg.Y) 48 } 49 50 func (msg *AteniKVMPointerEvent) Type() ClientMessageType { 51 return AteniKVMPointerEventMsgType 52 } 53 54 func (*AteniKVMPointerEvent) Read(c Conn) (ClientMessage, error) { 55 msg := AteniKVMPointerEvent{} 56 if err := binary.Read(c, binary.BigEndian, &msg); err != nil { 57 return nil, err 58 } 59 return &msg, nil 60 } 61 62 func (msg *AteniKVMPointerEvent) Write(c Conn) error { 63 if !msg.Supported(c) { 64 return nil 65 } 66 if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil { 67 return err 68 } 69 if err := binary.Write(c, binary.BigEndian, msg); err != nil { 70 return err 71 } 72 return c.Flush() 73 } 74 75 func (msg *AteniKVMKeyEvent) Supported(c Conn) bool { 76 return false 77 } 78 79 func (msg *AteniKVMKeyEvent) String() string { 80 return fmt.Sprintf("down:%d, key:%s", msg.Down, msg.Key) 81 } 82 83 func (msg *AteniKVMKeyEvent) Type() ClientMessageType { 84 return AteniKVMKeyEventMsgType 85 } 86 87 func (*AteniKVMKeyEvent) Read(c Conn) (ClientMessage, error) { 88 msg := AteniKVMKeyEvent{} 89 if err := binary.Read(c, binary.BigEndian, &msg); err != nil { 90 return nil, err 91 } 92 return &msg, nil 93 } 94 95 func (msg *AteniKVMKeyEvent) Write(c Conn) error { 96 if !msg.Supported(c) { 97 return nil 98 } 99 if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil { 100 return err 101 } 102 if err := binary.Write(c, binary.BigEndian, msg); err != nil { 103 return err 104 } 105 return c.Flush() 106 } 107 108 // AteniKVMFrontGroundEvent unknown aten ikvm message 109 type AteniKVMFrontGroundEvent struct { 110 _ [20]byte 111 } 112 113 func (msg *AteniKVMFrontGroundEvent) Supported(c Conn) bool { 114 return false 115 } 116 117 // String return string representation 118 func (msg *AteniKVMFrontGroundEvent) String() string { 119 return fmt.Sprintf("%v", msg.Type()) 120 } 121 122 // Type return ServerMessageType 123 func (*AteniKVMFrontGroundEvent) Type() ServerMessageType { 124 return AteniKVMFrontGroundEventMsgType 125 } 126 127 // Read unmarshal message from conn 128 func (*AteniKVMFrontGroundEvent) Read(c Conn) (ServerMessage, error) { 129 msg := &AteniKVMFrontGroundEvent{} 130 var pad [20]byte 131 if err := binary.Read(c, binary.BigEndian, &pad); err != nil { 132 return nil, err 133 } 134 return msg, nil 135 } 136 137 // Write marshal message to conn 138 func (msg *AteniKVMFrontGroundEvent) Write(c Conn) error { 139 if !msg.Supported(c) { 140 return nil 141 } 142 var pad [20]byte 143 if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil { 144 return err 145 } 146 if err := binary.Write(c, binary.BigEndian, pad); err != nil { 147 return err 148 } 149 return c.Flush() 150 } 151 152 // AteniKVMKeepAliveEvent unknown aten ikvm message 153 type AteniKVMKeepAliveEvent struct { 154 _ [1]byte 155 } 156 157 func (msg *AteniKVMKeepAliveEvent) Supported(c Conn) bool { 158 return false 159 } 160 161 // String return string representation 162 func (msg *AteniKVMKeepAliveEvent) String() string { 163 return fmt.Sprintf("%v", msg.Type()) 164 } 165 166 // Type return ServerMessageType 167 func (*AteniKVMKeepAliveEvent) Type() ServerMessageType { 168 return AteniKVMKeepAliveEventMsgType 169 } 170 171 // Read unmarshal message from conn 172 func (*AteniKVMKeepAliveEvent) Read(c Conn) (ServerMessage, error) { 173 msg := &AteniKVMKeepAliveEvent{} 174 var pad [1]byte 175 if err := binary.Read(c, binary.BigEndian, &pad); err != nil { 176 return nil, err 177 } 178 return msg, nil 179 } 180 181 // Write marshal message to conn 182 func (msg *AteniKVMKeepAliveEvent) Write(c Conn) error { 183 if !msg.Supported(c) { 184 return nil 185 } 186 var pad [1]byte 187 if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil { 188 return err 189 } 190 if err := binary.Write(c, binary.BigEndian, pad); err != nil { 191 return err 192 } 193 return c.Flush() 194 } 195 196 // AteniKVMVideoGetInfo unknown aten ikvm message 197 type AteniKVMVideoGetInfo struct { 198 _ [20]byte 199 } 200 201 func (msg *AteniKVMVideoGetInfo) Supported(c Conn) bool { 202 return false 203 } 204 205 // String return string representation 206 func (msg *AteniKVMVideoGetInfo) String() string { 207 return fmt.Sprintf("%v", msg.Type()) 208 } 209 210 // Type return ServerMessageType 211 func (*AteniKVMVideoGetInfo) Type() ServerMessageType { 212 return AteniKVMVideoGetInfoMsgType 213 } 214 215 // Read unmarshal message from conn 216 func (*AteniKVMVideoGetInfo) Read(c Conn) (ServerMessage, error) { 217 msg := &AteniKVMVideoGetInfo{} 218 var pad [40]byte 219 if err := binary.Read(c, binary.BigEndian, &pad); err != nil { 220 return nil, err 221 } 222 return msg, nil 223 } 224 225 // Write marshal message to conn 226 func (msg *AteniKVMVideoGetInfo) Write(c Conn) error { 227 if !msg.Supported(c) { 228 return nil 229 } 230 var pad [4]byte 231 if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil { 232 return err 233 } 234 if err := binary.Write(c, binary.BigEndian, pad); err != nil { 235 return err 236 } 237 return c.Flush() 238 } 239 240 // AteniKVMMouseGetInfo unknown aten ikvm message 241 type AteniKVMMouseGetInfo struct { 242 _ [2]byte 243 } 244 245 func (msg *AteniKVMMouseGetInfo) Supported(c Conn) bool { 246 return false 247 } 248 249 // String return string representation 250 func (msg *AteniKVMMouseGetInfo) String() string { 251 return fmt.Sprintf("%v", msg.Type()) 252 } 253 254 // Type return ServerMessageType 255 func (*AteniKVMMouseGetInfo) Type() ServerMessageType { 256 return AteniKVMMouseGetInfoMsgType 257 } 258 259 // Read unmarshal message from conn 260 func (*AteniKVMMouseGetInfo) Read(c Conn) (ServerMessage, error) { 261 msg := &AteniKVMFrontGroundEvent{} 262 var pad [2]byte 263 if err := binary.Read(c, binary.BigEndian, &pad); err != nil { 264 return nil, err 265 } 266 return msg, nil 267 } 268 269 // Write marshal message to conn 270 func (msg *AteniKVMMouseGetInfo) Write(c Conn) error { 271 if !msg.Supported(c) { 272 return nil 273 } 274 var pad [2]byte 275 if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil { 276 return err 277 } 278 if err := binary.Write(c, binary.BigEndian, pad); err != nil { 279 return err 280 } 281 return c.Flush() 282 } 283 284 // AteniKVMSessionMessage unknown aten ikvm message 285 type AteniKVMSessionMessage struct { 286 _ [264]byte 287 } 288 289 func (msg *AteniKVMSessionMessage) Supported(c Conn) bool { 290 return false 291 } 292 293 // String return string representation 294 func (msg *AteniKVMSessionMessage) String() string { 295 return fmt.Sprintf("%v", msg.Type()) 296 } 297 298 // Type return ServerMessageType 299 func (*AteniKVMSessionMessage) Type() ServerMessageType { 300 return AteniKVMSessionMessageMsgType 301 } 302 303 // Read unmarshal message from conn 304 func (*AteniKVMSessionMessage) Read(c Conn) (ServerMessage, error) { 305 msg := &AteniKVMSessionMessage{} 306 var pad [264]byte 307 if err := binary.Read(c, binary.BigEndian, &pad); err != nil { 308 return nil, err 309 } 310 return msg, nil 311 } 312 313 // Write marshal message to conn 314 func (msg *AteniKVMSessionMessage) Write(c Conn) error { 315 if !msg.Supported(c) { 316 return nil 317 } 318 var pad [264]byte 319 if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil { 320 return err 321 } 322 if err := binary.Write(c, binary.BigEndian, pad); err != nil { 323 return err 324 } 325 return nil 326 } 327 328 // AteniKVMGetViewerLang unknown aten ikvm message 329 type AteniKVMGetViewerLang struct { 330 _ [8]byte 331 } 332 333 func (msg *AteniKVMGetViewerLang) Supported(c Conn) bool { 334 return false 335 } 336 337 // String return string representation 338 func (msg *AteniKVMGetViewerLang) String() string { 339 return fmt.Sprintf("%v", msg.Type()) 340 } 341 342 // Type return ServerMessageType 343 func (*AteniKVMGetViewerLang) Type() ServerMessageType { 344 return AteniKVMGetViewerLangMsgType 345 } 346 347 // Read unmarshal message from conn 348 func (*AteniKVMGetViewerLang) Read(c Conn) (ServerMessage, error) { 349 msg := &AteniKVMGetViewerLang{} 350 var pad [8]byte 351 if err := binary.Read(c, binary.BigEndian, &pad); err != nil { 352 return nil, err 353 } 354 return msg, nil 355 } 356 357 // Write marshal message to conn 358 func (msg *AteniKVMGetViewerLang) Write(c Conn) error { 359 if !msg.Supported(c) { 360 return nil 361 } 362 var pad [8]byte 363 if err := binary.Write(c, binary.BigEndian, msg.Type()); err != nil { 364 return err 365 } 366 if err := binary.Write(c, binary.BigEndian, pad); err != nil { 367 return err 368 } 369 return c.Flush() 370 }