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  }