Class: Net::VNC

Inherits:
Object
  • Object
show all
Defined in:
lib/net/vnc.rb,
lib/net/vnc/version.rb

Overview

The VNC class provides for simple rfb-protocol based control of a VNC server. This can be used, eg, to automate applications.

Sample usage:

# launch xclock on localhost. note that there is an xterm in the top-left

require 'net/vnc'
Net::VNC.open 'localhost:0', :shared => true, :password => 'mypass' do |vnc|
  vnc.pointer_move 10, 10
  vnc.type 'xclock'
  vnc.key_press :return
end

TODO

  • The server read loop seems a bit iffy. Not sure how best to do it.

  • Should probably be changed to be more of a lower-level protocol wrapping thing, with the actual VNCClient sitting on top of that. all it should do is read/write the packets over the socket.

Defined Under Namespace

Classes: PointerState

Constant Summary collapse

BASE_PORT = 
5900
CHALLENGE_SIZE = 
16
DEFAULT_OPTIONS = 
{
  :shared => false,
  :wait => 0.1,
  :pix_fmt => :BGRA,
  :encoding => :RAW
}
KEY_MAP = 
YAML.load_file(keys_file).inject({}) { |h, (k, v)| h.update k.to_sym => v }
VERSION = 
'1.2.0'.freeze
BUTTON_MAP = 
{
  :left => 0
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(display = ':0', options = {}) ⇒ VNC

Returns a new instance of VNC.



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/net/vnc.rb', line 77

def initialize display=':0', options={}
  @server = 'localhost'
  if display =~ /^(.*)(:\d+)$/
    @server, display = $1, $2
  end
  @display = display[1..-1].to_i
  @desktop_name = nil
  @options = DEFAULT_OPTIONS.merge options
  @clipboard = nil
  @fb = nil
  @pointer = PointerState.new self
  @mutex = Mutex.new
  connect
  @packet_reading_state = nil
  @packet_reading_thread = Thread.new { packet_reading_thread }
end

Instance Attribute Details

#desktop_name ⇒ Object (readonly)

Returns the value of attribute desktop_name.



75
76
77
 
# File 'lib/net/vnc.rb', line 75

def desktop_name
  @desktop_name
end

#display ⇒ Object (readonly)

Returns the value of attribute display.



75
76
77
 
# File 'lib/net/vnc.rb', line 75

def display
  @display
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



75
76
77
 
# File 'lib/net/vnc.rb', line 75

def options
  @options
end

#pointer ⇒ Object (readonly)

Returns the value of attribute pointer.



75
76
77
 
# File 'lib/net/vnc.rb', line 75

def pointer
  @pointer
end

#server ⇒ Object (readonly)

Returns the value of attribute server.



75
76
77
 
# File 'lib/net/vnc.rb', line 75

def server
  @server
end

#socket ⇒ Object (readonly)

Returns the value of attribute socket.



75
76
77
 
# File 'lib/net/vnc.rb', line 75

def socket
  @socket
end

Class Method Details

.open(display = ':0', options = {}) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/net/vnc.rb', line 94

def self.open display=':0', options={}
  vnc = new display, options
  if block_given?
    begin
      yield vnc
    ensure
      vnc.close
    end
  else
    vnc
  end
end

Instance Method Details

#button_down(which = :left, options = {}) ⇒ Object

Raises:

  • (ArgumentError) 


248
249
250
251
252
253
 
# File 'lib/net/vnc.rb', line 248

def button_down which=:left, options={}
  button = BUTTON_MAP[which] || which
  raise ArgumentError, 'Invalid button - %p' % which unless (0..2) === button
  pointer.button |= 1 << button
  wait options
end

#button_press(button = :left, options = {}) ⇒ Object 



239
240
241
242
243
244
245
246
 
# File 'lib/net/vnc.rb', line 239

def button_press button=:left, options={}
  begin
    button_down button, options
    yield if block_given?
  ensure
    button_up button, options
  end
end

#button_up(which = :left, options = {}) ⇒ Object

Raises:

  • (ArgumentError) 


255
256
257
258
259
260
 
# File 'lib/net/vnc.rb', line 255

def button_up which=:left, options={}
  button = BUTTON_MAP[which] || which
  raise ArgumentError, 'Invalid button - %p' % which unless (0..2) === button
  pointer.button &= ~(1 << button)
  wait options
end

#clipboard ⇒ Object 



299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
 
# File 'lib/net/vnc.rb', line 299

def clipboard
  if block_given?
    @clipboard = nil
    yield
    60.times do
      clipboard = @mutex.synchronize { @clipboard }
      return clipboard if clipboard
      sleep 0.5
    end
    warn 'clipboard still empty after 30s'
    nil
  else
    @mutex.synchronize { @clipboard }
  end
end

#clipboard=(text) ⇒ Object 



315
316
317
318
319
320
321
322
323
324
 
# File 'lib/net/vnc.rb', line 315

def clipboard= text
  text = text.to_s.gsub(/\R/, "\n") # eol of ClientCutText's text is LF
  byte_size = text.to_s.bytes.size
  packet = 0.chr * (8 + byte_size)
  packet[0] = 6.chr # message-type: 6 (ClientCutText)
  packet[4, 4] = [byte_size].pack('N') # length
  packet[8, byte_size] = text
  socket.write(packet)
  @clipboard = text
end

#close ⇒ Object 



275
276
277
278
279
280
281
282
283
284
 
# File 'lib/net/vnc.rb', line 275

def close
  # destroy packet reading thread
  if @packet_reading_state == :loop
    @packet_reading_state = :stop
    while @packet_reading_state
      # do nothing
    end
  end
  socket.close
end

#connect ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/net/vnc.rb', line 111

def connect
  @socket = TCPSocket.open(server, port)
  unless socket.read(12) =~ /^RFB (\d{3}.\d{3})\n$/
    raise 'invalid server response'
  end
  @server_version = $1
  socket.write "RFB 003.003\n"
  data = socket.read(4)
  auth = data.to_s.unpack('N')[0]
  case auth
  when 0, nil
    raise 'connection failed'
  when 1
    # ok...
  when 2
    password = @options[:password] or raise 'Need to authenticate but no password given'
    challenge = socket.read CHALLENGE_SIZE
    response = Cipher::VNCDES.new(password).encrypt(challenge)
    socket.write response
    ok = socket.read(4).to_s.unpack('N')[0]
    raise 'Unable to authenticate - %p' % ok unless ok == 0
  else
    raise 'Unknown authentication scheme - %d' % auth
  end

  # ClientInitialisation
  socket.write((options[:shared] ? 1 : 0).chr)

  # ServerInitialisation
  @framebuffer_width  = socket.read(2).to_s.unpack('n')[0].to_i
  @framebuffer_height = socket.read(2).to_s.unpack('n')[0].to_i

  # TODO: parse this.
  pixel_format = socket.read(16)

  # read the name in byte chunks of 20
  name_length = socket.read(4).to_s.unpack('N')[0]
  @desktop_name = [].tap do |it|
    while name_length > 0
      len = [20, name_length].min
      it << socket.read(len)
      name_length -= len
    end
  end.join

  _load_frame_buffer
end

#key_down(which, options = {}) ⇒ Object 



209
210
211
212
213
214
215
216
217
 
# File 'lib/net/vnc.rb', line 209

def key_down which, options={}
  packet = 0.chr * 8
  packet[0] = 4.chr
  key_code = get_key_code which
  packet[4, 4] = [key_code].pack('N')
  packet[1] = 1.chr
  socket.write packet
  wait options
end

#key_press(*args) ⇒ Object

this takes an array of keys, and successively holds each down then lifts them up in reverse order. FIXME: should wait. can’t recurse in that case.

Raises:

  • (ArgumentError) 


176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/net/vnc.rb', line 176

def key_press(*args)
  options = Hash === args.last ? args.pop : {}
  keys = args
  raise ArgumentError, 'Must have at least one key argument' if keys.empty?
  begin
    key_down keys.first
    if keys.length == 1
      yield if block_given?
    else
      key_press(*(keys[1..-1] + [options]))
    end
  ensure
    key_up keys.first
  end
end

#key_up(which, options = {}) ⇒ Object 



219
220
221
222
223
224
225
226
227
 
# File 'lib/net/vnc.rb', line 219

def key_up which, options={}
  packet = 0.chr * 8
  packet[0] = 4.chr
  key_code = get_key_code which
  packet[4, 4] = [key_code].pack('N')
  packet[1] = 0.chr
  socket.write packet
  wait options
end

#pointer_move(x, y, options = {}) ⇒ Object 



229
230
231
232
233
 
# File 'lib/net/vnc.rb', line 229

def pointer_move x, y, options={}
  # options[:relative]
  pointer.update x, y
  wait options
end

#port ⇒ Object 



107
108
109
 
# File 'lib/net/vnc.rb', line 107

def port
  BASE_PORT + @display
end

#reconnect ⇒ Object 



286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'lib/net/vnc.rb', line 286

def reconnect
  60.times do
    if @packet_reading_state.nil?
      connect
      @packet_reading_thread = Thread.new { packet_reading_thread }
      return true
    end
    sleep 0.5
  end
  warn 'reconnect failed because packet reading state had not been stopped for 30 seconds.'
  false
end

#take_screenshot(dest = nil) ⇒ String

take screenshot as PNG image

Parameters:

  • dest (String|IO|nil) (defaults to: nil) —

    destination file path, or IO-object, or nil

Returns:

  • (String) —

    PNG binary data as string when dest is null

    true

    else case



266
267
268
269
 
# File 'lib/net/vnc.rb', line 266

def take_screenshot(dest=nil)
  fb = _load_frame_buffer  # on-demand loading
  fb.save_pixel_data_as_png dest
end

#type(text, options = {}) ⇒ Object

this types text on the server



160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/net/vnc.rb', line 160

def type text, options={}
  packet = 0.chr * 8
  packet[0] = 4.chr
  text.split(//).each do |char|
    packet[7] = char[0]
    packet[1] = 1.chr
    socket.write packet
    packet[1] = 0.chr
    socket.write packet
  end
  wait options
end

#wait(options = {}) ⇒ Object 



271
272
273
 
# File 'lib/net/vnc.rb', line 271

def wait options={}
  sleep options[:wait] || @options[:wait]
end