Merge branch 'master' of git@github.com:kanaka/noVNC

wsproxy: warn when no cert. C sock close cleanup.

Warn early about no SSL cert and add clearer warning when a connection
comes in as SSL but no cert file exists.

For the C version, cleanup closing of the connection socket. Use
shutdown for a cleaner cleanup with the client.

README: add companies/projects using noVNC.

include/canvas.js: show full user agent in console.

include/rfb.js: show Flash version in console.

Expose getKeysym and add keyboard test.

Related to issue Non-US keyboard layout option issue:
https://github.com/kanaka/noVNC/issues#issue/21

utils/README.md, docs/TODO, docs/notes: updates.

Add wswrapper info to utils/README.md and docs/TODO. Remove innacurate
info from docs/notes.

wswrapper: update README, DO_MSG def for output.

Update README to mention wswrapper. Add DO_MSG define which controls
whether wswrapper code generates basic output.

wswrapper: interpose on poll/ppoll also.

poll/ppoll interposer builds but is untested.

wswrapper: timeout select.

The select call needs to timeout if a WebSocket socket keeps reporting
ready but actually isn't ready. To prevent it hanging forever in that
condition, the timeout value is now adjusted now for each call.

Move the DO_DEBUG and DO_TRACE settings to wswrapper.c.

wswrapper: interpose select/pselect. Cleaup.

Interpose on select/pselect so that WebSockets sockets are only
reported as ready if they have enough to actually decode at least
1 byte of real data. This prevents hanging in read/recv after
WebSocket is reported as ready but is not actually ready because empty
frames or less than four base64 bytes have been received.

Split defines and constant defintions into wswrapper.h.

Cleanup debug output and add TRACE for more detailed tracing debug
output.

Major TODO is that select needs to timeout if WebSocket socket keeps
reporting ready but actually isn't ready. That condition will
currently hang forever because the select timeout value is not
adjusted when looping.

Fix to "Tolerate fragmented ServerInit".

Issue #39: https://github.com/kanaka/noVNC/issues/issue/39

Tolerate fragmented ServerInit.

Issue #39: https://github.com/kanaka/noVNC/issues/issue/39

utils/launch.sh: find top web dir (with vnc.html).

use cd, dirname, and pwd to determine path instead of readlink (Mac fix)

set socket option SO_REUSEADDR to prevent  "Address already in use" error

wswrapper: fix preload path and interpose port.

Make path to ld preload library absolute so wswrapper works even if
path is changed before main program is executed (i.e. by the vncserver
wrapper script).

bind() was using the return value for the port number, but it's
actually the original port number that we should interpose on in the
bind() routine.

wswrapper: Normalize comments, remove unused headers.

wswrapper: Allow multiple WebSockets connections.

Allocate buffer and state memory for each accepted connection. This
allows all WebSockets connections to a given listen port to be wrapped
with WebSockets support.

wswrap: WSWRAP_PORT envvar and wswrap script.

wswrapper.so will only interpose on the listen port specified in
WSWRAP_PORT.

Add simple wswrap script that sets the WSWRAP_PORT, LD_PRELOAD and
invokes the command line to wrap.

Make compatible with jQuery. Slight API change.

Rename the $() selector to $D() so that it doesn't collide with
the jQuery name.

The API change is that the 'target' option for Canvas and RFB objects
must now be a DOM Canvas element. A string is no longer accepted
because this requires that a DOM lookup is done and the Canvas and RFB
should have no UI code in them. Modularity.

wswrapper: wrap existing server using LD_PRELOAD.

wswrapper.so is LD_PRELOAD shared library that interposes and turns
a generic TCP socket into a WebSockets service.

This current version works but will only allow work for a single
connection, subsequent connections will not be wrapped. In addition
the wrapper interposes on the first incoming network connection. It
should read an environment variable to determine the port to interpose
on. Also, should limit origin based on another environment variable.
Then there should be a wswrap setup script that allows easier
invocation.

rfb.js: avoid multiple b64 sequences per frame.

Only call encode_message when the WebSockets object is actually
ready to send. Otherwise multiple base64 encode sequences can be
encoded into the same WebSockets frame. This causes the C version of
wsproxy to crash and the python version to ignore the subsequent
base64 sequence(s).

Thanks to Colin Dean (xvpsource.org) for finding this and helping
track it down.

Rename default_controls.js to ui.js.

And DefaultControls to UI.

Add Chrome Frame support. Close requests in web.py.

- Add meta tag to vnc.html and vnc_auto.html so that if Chrome Frame
  is installed, it is used.

- Add detection to default_controls.js that shows a message with
  a Chrome Frame install link if the user is using a version of IE
  without Canvas support.

- Fix web.py so that requests have their connection closed after they
  are completed.  This has been a bug for a while but it prevents
  Chrome Frame from working because Chrome Frame doesn't activate
  until the initial request connection closes.

wsproxy.js: Fix multi-frame decoding.

- Also, discovered node.js bug in base64 decoding. Added test case and
  filed https://github.com/ry/node/issues/issue/402

First pass at wsproxy using node (node.js).

Node:
    http://nodejs.org/
    https://github.com/ry/node

It mostly works, but it eventually gets an error from the target which
is probably due to missing support for re-assembly of client
WebSockets frames.

wsproxy: Fix --key parameter use.

Fix flush with strict DOCTYPE.

- With a strict doctype, the margin size needs a "px" suffix.

canvas.js: workaround WebKit bug, issue #28.

This is WebKit bug https://bugs.webkit.org/show_bug.cgi?id=46319

The workaround is to wrap Canvas render functions with a function that
sets a flush timer. The flush function sets the right margin and then
1ms later sets it back. This triggers the canvas to redraw with the
correct contents.

Two downsides:
- rendering is slower, but only on the busted versions of webkit.
  Correct and useful is better than fast and useless.
- There is a barely perceptible jitter of the control buttons because
  the canvas size is changing by one pixel.

To support this functionality, we also have to read out the exact
webkit version from the user agent in the render engine detection code
in include/util.js.

default_controls.js: canvas fail fix. Misc cleanup.

- Make sure that canvas exists (i.e. didn't throw an error) before
  trying to call canvas method get_canvas_uri.

- Typos in HTML render engine debug output.

Add --key option for separate cert and key file.

If only --cert is specified then continue to assume both certificate
and key are in the same file (key first).

Remove left over record code. Squelch compile warnings

wsproxy: Mac OS X build fixes

- pass CFLAGS and LDFLAGS in case one needs to use -m32
- link to libcrypto for _ERR_print_errors_fp
- __THROW is non-standard define it to nothing by default
- use b64_ntop and b64_pton instead of mangled versions, OSX doesn't mangle them in the same way
- access() takes two arguments!

Signed-off-by: François Revol <revol@free.fr>

Issue #34: fix RFB 3.3/3.7 with no auth scheme.

- Split out ClientInitialisation state.

- In version 3.3 and 3.7, when the server has no auth (scheme
  1), then we should skip from Authentication to ClientInitialisation.

utils/README.md: second try on cmd formatting.

utils/README.md: Fix command formatting.

Issue #32, wsproxy README, update webkit bug info,

- Add wsproxy README.md in utils/ directory.

- Document how to build ssl module for python 2.5 and older in wsproxy
  README.

- Update browsers.md to note revision that have the webkit Canvas
  rendering bug: WebKit build 66396 through 68867 (Chrome/Chromium
  build 57968 through 61278).

Expose VNC shared mode setting in UIs.

If shared mode is false, then the server should disconnect other
connections before the current connection is allowed to proceed.

Fix style caching. Canvas cleanup from Diet-noVNC.

- Style caching gives a small performance speedup in firefox, but not
  much. Might not be worth complexity, but leave it in for now.

Fix reason_len not defined bug.

rfb.js: fail() wrapper for common failed pattern.

Add manual flash policy socat server info.

utils/Makefile: clean up md5.o too.

rfb.js: rQwait, cuttext simplification.

- rQwait checks the receive queue to see if there is enough data to
  satisfy the following request. If not it returns true (which is
  almost always translated into an immediate return false by the
  caller).

- rQwait is called quite a bit and this generally allows 4 lines to
  become 1 line where it is called.

- rQwait allows simplification of cuttext processing. No global
  tracking needed anymore.

Overall, about 60 lines less code.

include/des.js: trim some fat.

DES is just used once during authentication and is not performance
sensitive so we save some space by generating and/or removing some
lookup tables. Also, shorten some very frequently used variables.

Shaves off about 100 lines.

webutil.js, util.js: split cleanup.

Merge branch 'master' of git@github.com:kanaka/noVNC

Split util into two file:
 - util.js that contains essential functions
 - webutils.js that contains the GUI utility function.js

this helps to include noVNC in other project, especially Cappuccino Application
i

des.js: remove decrypt and simplify.

The decrypt functionality is never used so remove it. Also, we can
assume that we are always DES encrypting 16 characters which allows
several things to be simplified in DES.

Overall this removes about 80 lines of code.

Show rect/enc counts, add vnc_perf.html test.

- include/rfb.js: Keep track of the number of rects of each encoding
  type and print them out when we close a connection (if 'info'
  logging level).

- tests/vnc_perf.html: first pass at a noVNC based performance
  benchmark.

- utils/wsproxy.py: Fix the output of the record filename.

rfb.js, canvas.js: status feedback on Canvas functionality.

Read the render mode selected by canvas and report it in the initial
page loaded status message.

docs/browsers.md: noVNC webkit bug link format.

README.md: move browser page link.

README.md: add link to browsers.md, update requirements.

docs/browsers.md: Separate browser support page.

Refactor settings object, add connectTimeout setting.

- include/util.js: Add type and desc field to conf_default routine.
  Make comment descriptions of settings into desc parameters that can
  be queried. Also, use set_FOO in conf_default to set or coerce the
  current setting so that we always have the right type for the value.

- include/rfb.js, include/default_config.js: add connectTimeout
  setting to address situations with slow connections that may need
  more than 2 seconds.

rfb.js: wait for SecurityResult failure reason bytes.

Yet another weird VNC server behavior: sending a failure and length
before the reason message. To calculated the length, the reason string
is already available, why not just send everything as one packet. Oh
well.

Misc cleanup: debug logging, record filename, etc.

- include/canvas.js: When 'debug' logging, show browser detection
  values.
- test/canvas.html: Only restore the canvas to it's starting state if
  the logging level is not 'debug'.
- wsproxy.py: Append the session number to the record filename so that
  multiple sessions don't stomp on each other.

util.js: detect firefox 4.X correctly.

Update the browser detection code (from mootools) with a fix that
detects firefox 4.0 correctly.

logging: add Util.get_logging(), canvas clearing.

Only clear canvas if log level is not debug instead of using
'#__debug__' in the URL.

playback.js: move to include/ for easier reference.

Easier to reference from web site (gh-pages branch).

No local cursor by default due to issues #27, #29.

In Safari, local cursor rendering is corrupt. In firefox 3.6.10, local
cursor rendering causes a segfault. Probable that the .cur format is
not 100% compliant (even though it works in Chrome and firefox 3.5 and
firefox 4.0). So just disable it by default until I can figure out how
to address the problems.

C proxy: Issue #14: wss:// from Safari

Addresses this issue:
http://github.com/kanaka/noVNC/issues#issue/14

This goes along with commit 7e63919e6 but for the C proxy.

API change: add sendKey() to manually send key code.

RFB.sendKey(code, down)

If down is not specified then both a down followed by an up code will
be sent.

proxy: Issue #14: detect and allow wss:// from Safari.

Addresses this issue:
http://github.com/kanaka/noVNC/issues#issue/14

Safari starts with '\x80' rather than '\x16' like Chrome and Firefox
and having PROTOCOL_TLSv1 doesn't work with Safari. But just removing
the ssl_version allows things to work with Safari wss:// connections.

Also, if the handshake (after SSL wrapping) is null then terminate the
connection. This probably means the certificate was refused by the
client. Unfortunately Safari (the version I have) doesn't cleanly
shutdown WebSockets connections until the page is reloaded (even if
the object is no longer referenced).

rfb.js: state refactor, add 'disconnect' state.

Add a new state 'disconnect' to reflect that we are not truly
'disconnected' until we get an onclose event. Add a disconnect timer
to match.

Handle disconnected cleanup better in updateState(). Anytime we enter
in a disconnect/disconnected state, make sure all running state is
cleaned up (WebSocket, timers, canvas).

proxy: always multiprocess and add --verbose.

Always fork handlers processes. Instead printing traffic when
single-processing, print traffic if verbose flag given.

web-socket-js (issue #37): close() when connecting

Filed this issue for this bug:
http://github.com/gimite/web-socket-js/issues/issue/37

Right now the close() call only calls __flash.close() if readyState is OPEN.
But it should really call close any time that readyState is not CLOSED or
CLOSING.

The case I ran into is when I want to do the following:
1. make a test connection
2. tell the server to setup for a connection
3. connect again

I call close on the test connection, but since it is ignored when CONNECTING,
it eventually times out with a error. But by that time I have already issued a
new connection, it causes the new connection to fail. close() should cancel
CONNECTING state too.

gimite/web-socket-js issue #35: async onclose.

Filed this bug about this issue:
http://github.com/gimite/web-socket-js/issues#issue/35

To work around the flash "recursive call" problem, WebSocket.as has
the onclose event disabled in the close() call and the javascript half
of the close() call does the onclose() call instead. This is fine, but
it needs to be asynchronous to act more like what happens with
a normal WebSockets object. The current behavior is that the onclose()
method is called inline (synchronously) when the close() is called and
this inconsistency make state handling more difficult.

proxy: do handshake in forked process too.

wsproxy: multiprocess capable.

Add -m, --multiprocess option which forks a handler for each
connection allowing multiple connections to the same target using the
same proxy instance.

Cleaned up the output of the handler process. Each process' output is
prefixed with an ordinal value.

Changed both the C and python versions of the proxy.

Remove record option from C wsproxy.

I've decided that debug/develop/extra features will just be in the
python version of the proxy. The C version (and other versions) will
just have the core functionality (unless someone wants to support it).

License header cleanup.

web-socket-js: 9e7663771 build and remove source.

web-socket-js now has all the functionality and fixes needed for noVNC
so remove the include/as3crypto_patched directory and the
include/web-socket-js/flash-src directory (i.e. the sources for
web-socket-js). This cleans up almost 3K from the include/ directory.

Update to web-socket-js build based on upstream (gimite/web-socket-js)
9e766377188.

default_controls.js: Fix cursor setting init.

The rfb variable wasn't available at the point settingsDisabled() was
being called since it was called inline with RFB() initialization. To
solve this we pass the updateState rfb variable so that the canvas can
be queried for setting the cursor_uri value.

TODO and .gitignore: updates.

JSLint.

vnc_playback.html: print frame_idx on error.

Encrypt default to 'false' in vnc_auto.html also.

playback.js: realtime playback and split out code.

Preparation for online demo.

Split general playback code into tests/playback.js.

Use timestamps from recording with proxy to playback in realtime.

TODO: move long-term features to github issues.

Issue #15 - rfb.js: wait for security type list.

Apparently the virtualbox VNC server send the size and then the
security type list in separate frames so we need to wait for the full
list.

canvas.js: Fix ignore for scrolled window.

When the documement/window is scrolled, the onMouseDisable routine was
not properly calculating the position to test whether to ignore the
event or not.

Rename tightpng img queue variable to imgQ.

More timing "history" purge.

rfb.js: JSLint'ing

Change RQ and SQ vars to rQ and sQ since caps at the start implies
a classable entity.

Merge init() into the constructor.

This is logical now since the external update callback can be provided
when the object is created so we don't need a separate init function.

Remove psuedo-UTF8 encoding.

It's less efficient on average that base64 (150% vs 133%). It's
non-standard (0 shifted to 256 before encoding). And I rarely use it.

rfb.js: remove timing history.

Turned out not to be useful (pretty much never looked at the info once
I added it). The playback test is much more useful for measuring
performance.

rfb.js/tight_png: fix indexed receive queue handling.

getCLength was not using the index (RQi) into the receive queue.

Test both builtin and base64.js functions.

Indexed receive queue. Up to 2X speedup in Chrome.

Generally, most servers send hextile updates as single updates
containing many rects. Some servers send hextile updates as many small
framebuffer updates with a few rects each (such as QEMU). This latter
cases revealed that shifting off the beginning of the receive queue
(which happens after each hextile FBU) performs poorly.

This change switches to using an indexed receive queue (instead of
actually shifting off the array). When the receive queue has grown to
a certain size, then it is compacted all at once.

The code is not as clean, but this change results in more than 2X
speedup under Chrome for the pessimal case and 10-20% in firefox.

Add Javascript variable container to record data.

- This allows the recorded data to be immediately usable by
  tests/vnc_playback.html

Treat RFB 3.6 as 3.3.

Apparently there are versions of UltraVNC that report version 3.6.
This is not a legal version according to the spec, but we'll just
force version 3.3 if we receive it. Thanks to Larry Rowe for the info.

Scroll render test and perf speedup.

Turns out when Windows is running in QEMU and a window scroll happens,
there are lots of little hextile rects sent. This is slow in noVNC.

- Some recording/playback improvement.
- Add test harness to drive playback of recordings.
- By pulling off the rect header in one chunk we get a 3X speedup in
  Chrome and a 20% speedup in firefox (specifically for the scroll
  test).
- Also, get rid of some noise from creating timers for handle_message.
  Check to make sure there isn't already a pending timer first.

* take care of kanaka's suggestions
(cherry picked from commit 11f3271a52505dccbf38bea422e7c9a79dddd478)

Signed-off-by: Joel Martin <github@martintribe.org>

* Adding a way to set the DOM document to use.
This is very usefull when you need to open a new window (with a new document) from javascript,
without having to reload the script.js.
(cherry picked from commit 8ded53c1de06d01e50d58543c19e73926f0fbbd4)

Signed-off-by: Joel Martin <github@martintribe.org>

JSLint: use ===.

Remove unused imports (sys, ssl) in wsproxy.py