Import as3crypto_patch: ffda6e9cd8b1d74f45472c676afda8360ae1e5aa

as3crypto is actionscript 3 crypto library with TLS engine support.

From: http://github.com/lyokato/as3crypto_patched

Which was forked from: http://code.google.com/p/as3crypto/

Don't erase failed state error messages on disconnect.

Also send errors to console.error

wstest*. Fix Opera problems. Flash policy. Misc bugs.

Lame. Opera doesn't support javascript reduce().

Also, Opera seems to just plain be pathetic when it comes to
delivering the web-socket-js events. Around 1/5 to 1/3 of all received
packets are never received as an event at all.

- Change default delay for send side to 10ms.

- Use a textarea for errors so that even without console.* support
  (ala firebug) we still see the errors that are happening.

README.md typo and clarify.

Update README.md and TODO.

Send seq nums and b64 encode based on query string.

Query string variable 'b64encode' determine if wsproxy b64 encodes the
results. Variable 'seq_num' determines if sequence numbers are
prepended. This way, sequence numbers are only used with the flash
WebSocket proxy.

Status/error refactor. Fix firefox bugs.

- All state/status updates go through updateState routine which
  updates the status line also.

- Old firefox (and opera) don't support canvas createImageData, so use
  getImageData as replacement.

- Add console.warn and console.error stubs so that firefox without
  firebug doesn't crap out.

- If no WebSockets then error if no flash or if URL is location (flash
  will refuse to load the object for security reasons).

Remove mootools-more references.

Fix firefox '-' key mapping.

Add fixing firefox '-' key mapping issue to TODO.

Handle socket policy response in proxy itself.

Add web-socket-js support with packet re-ordering.

- web-socket-js is from http://github.com/gimite/web-socket-js. It is
  a flash object that emultates WebSockets.

Unfortunately, events (or packets) from the web-socket-js object can
get re-ordered so we need to know the packet order.

- So wsproxy.py prepends the sequence number of the packet when
  sending.

- If the client receives packets out of order it queues them up and
  scans the queue for the sequence number it's looking for until
  things are back on track. Gross, but hey: It works!

- Also, add packet sequence checking to wstest.*

Import web-socket-js: a0fb3933ce5c824bcb882f5a1cf87e46de773ea8

web-socket-js is a flash based WebSockets emulator.

From: http://github.com/gimite/web-socket-js

Reassemble partial client packets in wsproxy.py

Assemble partial received frames.

Apparently both native and flash WebSockets implementations can send
partial packets.

Add WebSockets test frontend and backend.

Remove uneeded mootools functions and used compressed version.

Clarify DES code origination.

Switch to MPL/GPL base64 from Mozilla.

- Also slightly better performance.

Update TODO and small perf cleanups.

Add cut and paste support.

- A textarea below the VNC area represents the state of the current
  VNC clipboard. If there is a server cut event, the textarea will be
  updated. If the user updates the contents of the textarea, the new
  data will be sent as a client paste (cut) event.

- One important change was to detect if the clipboard is focused and
  allow the user to type in the clipboard instead of in the VNC area.

In TODO: RRE framing bug fixed in prev refactor.

Refactor FBU.bytes handling to simplify.

- raw encoding displays horizontal lines as they arrive for better
  feedback and less time hanging waiting for something.

stop routine stops mouseMove events too.

Note WSS/SSL and C wsproxy in TODO.

Add TODO.

Working VNC client! Add mouse movement support.

- Mouse movements are accumulated and sent about 5 times a second.
- Normal polling happens at about 1.5 seconds intervals.

This commit represents a very functional VNC client under Google
Chrome.

Remaining work:

    - Cut and paste support.

    - Framing bugs when using RRE encoding.

    - Better status and error feedback.

    - Get working in firefox using flash web-socket-js:
        http://github.com/gimite/web-socket-js

    - Version without mootools (but test cross-browser).

Rename canvas.js routines to not have "rfb" prefix.

- Also, try making set fillStyle called less often.

Don't clear canvas if debug mode

Re-order routines, no functional changes.

Better hextile performance: index subrects instead of slicing/shifting.

- Many times better performance. Before this, browser was spending all
  it's time garbage collecting or doing something. Now the bottleneck
  is in set fillStyle and fillRect which is probably where it should
  be.

Fix some framing bugs. Cleanup console logs.

Refactor data processing. Ignore other server messages.

- Refactor to pull off all the data received into RFB.d array and then
  process it. This allows a bit more flexibility in handling
  data that isn't sent in frame boundary packets.

- Properly ignore these server messages: SetColourMapEntries, Bell,
  ServerCutText.

Initial mouse support. Down and Up only.

Hextile working. Improve latency by coallescing sends.

- Hextile has an undocumented weirdness where RAW frames are often
  followed by a 0 byte that should be ignored.

- Coallesce client messages that are one after another. Without
  this the server seems to often ignore frames that are send right
  after another frame has been sent. This fixes a reconnect issue
  where setEncodings seems to be ignored. Also results in a huge
  performance increase after key strokes (by adding a update request
  to the key event message) because the server always sends an update
  instead of sometimes waiting for the next poll to be sent.

Remove event handlers on disconnect.

Switch to much faster console.log and separate utils into util.js.

Refactor processing to allow hextile processing.

With hextile you can't know how many bytes are pending. So restructure
so that all the received data so far is passed to the processsing
routines.

Process RRE in chunks instead of 1 at a time.

Change to RGB ordering.

Working RRE implementation.

First pass at RRE encoding

WebWorkers example with two way messages.

- Prime number background worker that can be started, stopped and
  reset that calculates prime numbers and sends them back to the main
  page/thread.

Handle undefined URL values correctly.

Change depth to count down correctly. Trim long lines.

Fix Copy-Rect encoding.

Make web.py match README. Remove unused ws_echo.py.

List for proxy reasons.

Change to markdown README.md.

- Semi-colon missing.

Add README.

Remove old test files.

Cleanup of files and vnc.js namespace.

- Trim unused code in base64.js

Create getKeysym to lookup keysym from keyCode.

- Most of the keyboard is now functional.

Fix canvas.html.

Better interface, support user provided VNC password.

- host, port and password input boxes (populated by URL values).
- clear canvas on disconnect.
- Dotted border around VNC area.
- mirror bits for VNC password.

Got DES encryption of password working and colors corrected.

- DES encryption for VNC bit mirrors every bytes of the password. This
  commit has a hard-coded mirrored password. Need to ask user and bit
  mirror it.

- With image data across the wire it's Blue,Green,Red, so twiddle
  things around a bit.

Working with Raw rectangles and capital letter keys.

Cleanup canvas and vnc code so they can be used together.

Add Canvas and event experiments.

Correctly handles all three mouse buttons and key presses on firefox
and Chrome.

Has a decent obj properties lister (dirObj).

Do base64 encode/decode of stream. Send SetEncoding and FB update request.

Base64 Javascript encode/decode library.

From http://www.webtoolkit.info/

Base64 encode/decode for client Javascript.

First RFB protocol stub implementation.

- Requires wsproxy to proxy to the VNC server.

Add minimal python directory web server.

Add RFB specs and move *.js files into include/

Some wsproxy simplifications.

Web Socket to TCP socket proxy and HTML interface.

- wsproxy.py: creates a web sockets to TCP socket proxy.
- interact.html: prints received Web Sockets data and has text box to
  send strings.

Simplify ws_echo.py code.

Simpler non-threaded ws_echo.py

Note enter into ws onclose.

Add server and client HTML echo test and mootools library