Skip to content

N
noVNC
Commit f2538f33 authored by Joel Martin's avatar Joel Martin
Browse files
Options

wsproxy, wstelnet: wrap command, WS telnet client. 

wswrapper:

    Getting the wswrapper.c LD_PRELOAD model working has turned out to
    involve too many dark corners of the glibc/POSIX file descriptor
    space. I realized that 95% of what I want can be accomplished by
    adding a "wrap command" mode to wsproxy.

    The code is still there for now, but consider it experimental at
    best. Minor fix to dup2 and add dup and dup3 logging.

wsproxy Wrap Command:

    In wsproxy wrap command mode, a command line is specified instead
    of a target address and port. wsproxy then uses a much simpler
    LD_PRELOAD library, rebind.so, to move intercept any bind() system
    calls made by the program. If the bind() call is for the wsproxy
    listen port number then the real bind() system call is issued for
    an alternate (free high) port on loopback/localhost.  wsproxy then
    forwards from the listen address/port to the moved port.

    The --wrap-mode argument takes three options that determine the
    behavior of wsproxy when the wrapped command returns an exit code
    (exit or daemonizing): ignore, exit, respawn.

    For example, this runs vncserver on turns port 5901 into
    a WebSockets port (rebind.so must be built first):

        ./utils/wsproxy.py --wrap-mode=ignore 5901 -- vncserver :1

    The vncserver command backgrounds itself so the wrap mode is set
    to "ignore" so that wsproxy keeps running even after it receives
    an exit code from vncserver.

wstelnet:

    To demonstrate the wrap command mode, I added WebSockets telnet
    client.

    For example, this runs telnetd (krb5-telnetd) on turns port 2023
    into a WebSockets port (using "respawn" mode since telnetd exits
    after each connection closes):

        sudo ./utils/wsproxy.py --wrap-mode=respawn 2023 -- telnetd -debug 2023

    Then the utils/wstelnet.html page can be used to connect to the
    telnetd server on port 2023. The telnet client includes VT100.js
    (from http://code.google.com/p/sshconsole) which handles the
    terminal emulation and rendering.

rebind:

    The rebind LD_PRELOAD library is used by wsproxy in wrap command
    mode to intercept bind() system calls and move the port to
    a different port on loopback/localhost. The rebind.so library can
    be built by running make in the utils directory.

    The rebind library can be used separately from wsproxy by setting
    the REBIND_OLD_PORT and REBIND_NEW_PORT environment variables
    prior to executing a command. For example:

        export export REBIND_PORT_OLD="23"
        export export REBIND_PORT_NEW="65023"
        LD_PRELOAD=./rebind.so telnetd -debug 23

    Alternately, the rebind script does the same thing:

        rebind 23 65023 telnetd -debug 23

Other changes/notes:

- wsproxy no longer daemonizes by default. Remove -f/--foreground
  option and add -D/--deamon option.

- When wsproxy is used to wrap a command in "respawn" mode, the
  command will not be respawn more often than 3 times within 10
  seconds.

- Move getKeysym routine out of Canvas object so that it can be called
  directly.
parent 86725f9b
Expand all Show whitespace changes
Inline Side-by-side
Showing with 1080 additions and 219 deletions
README.md
View file @ f2538f33
...@@ -133,20 +133,20 @@ There a few reasons why a proxy is required: ...@@ -133,20 +133,20 @@ There a few reasons why a proxy is required:
* To run the python proxy directly without using launch script (to * To run the python proxy directly without using launch script (to
pass additional options for example): pass additional options for example):
`./utils/wsproxy.py -f source_port target_addr:target_port` `./utils/wsproxy.py source_port target_addr:target_port`
`./utils/wsproxy.py -f 8787 localhost:5901` `./utils/wsproxy.py 8787 localhost:5901`
* To run a mini python web server without the launch script: * To activate the mini-webserver in wsproxy.py use the `--web DIR`
option:
`./utils/web.py PORT` `./utils/wsproxy.py --web ./ 8787 localhost:5901`
`./utils/web.py 8080`
* Point your web browser at http://localhost:8080/vnc.html * Point your web browser at http://localhost:8787/vnc.html. On the
(or whatever port you used above to run the web server). Specify the page enter the location where the proxy is running (localhost and
host and port where the proxy is running and the password that the 8787) and the password that the vnc server is using (if any). Hit
vnc server is using (if any). Hit the Connect button. the Connect button.
* If you are using python 2.3 or 2.4 and you want wsproxy to support * If you are using python 2.3 or 2.4 and you want wsproxy to support
'wss://' (TLS) then see the 'wss://' (TLS) then see the
......
docs/TODO
View file @ f2538f33
...@@ -20,11 +20,7 @@ Short Term: ...@@ -20,11 +20,7 @@ Short Term:
- Clipboard button -> popup: - Clipboard button -> popup:
- text, clear and send buttons - text, clear and send buttons
- wswrapper: - wstelnet: support CSI L and CSI M
- Flash policy request support.
- SSL/TLS support.
- Tests suite:
- test pselect/poll/ppoll
Medium Term: Medium Term:
......
include/canvas.js
View file @ f2538f33
This diff is collapsed.
utils/Makefile
View file @ f2538f33
TARGETS=wsproxy wswrapper.so TARGETS=wsproxy wswrapper.so rebind.so
CFLAGS += -fPIC CFLAGS += -fPIC
all: $(TARGETS) all: $(TARGETS)
...@@ -10,6 +10,9 @@ wswrapper.o: wswrapper.h ...@@ -10,6 +10,9 @@ wswrapper.o: wswrapper.h
wswrapper.so: wswrapper.o md5.o wswrapper.so: wswrapper.o md5.o
$(CC) $(LDFLAGS) $^ -shared -fPIC -ldl -lresolv -o $@ $(CC) $(LDFLAGS) $^ -shared -fPIC -ldl -lresolv -o $@
rebind.so: rebind.o
$(CC) $(LDFLAGS) $^ -shared -fPIC -ldl -o $@
websocket.o: websocket.c websocket.h md5.h websocket.o: websocket.c websocket.h md5.h
wsproxy.o: wsproxy.c websocket.h wsproxy.o: wsproxy.c websocket.h
wswrapper.o: wswrapper.c wswrapper.o: wswrapper.c
......
utils/README.md
View file @ f2538f33
## WebSockets Utilities: wswrapper and wsproxy ## WebSockets Proxy
### wswrapper
wswrapper is an LD_PRELOAD library that converts a TCP listen socket
of an existing program to a be a WebSockets socket. The `wswrap`
script can be used to easily launch a program using wswrapper. Here is
an example of using wswrapper with vncserver. wswrapper will convert
the socket listening on port 5901 to be a WebSockets port:
`cd noVNC/utils`
`./wswrap 5901 vncserver -geometry 640x480 :1`
### wsproxy ### wsproxy
...@@ -32,7 +19,7 @@ does not end in 255). ...@@ -32,7 +19,7 @@ does not end in 255).
These are not necessary for the basic operation. These are not necessary for the basic operation.
* Daemonizing: When the `-f` option is not specified, wsproxy runs * Daemonizing: When the `-D` option is specified, wsproxy runs
in the background as a daemon process. in the background as a daemon process.
* SSL (the wss:// WebSockets URI): This is detected automatically by * SSL (the wss:// WebSockets URI): This is detected automatically by
...@@ -50,67 +37,63 @@ These are not necessary for the basic operation. ...@@ -50,67 +37,63 @@ These are not necessary for the basic operation.
sent and received from the client to a file using the `--record` sent and received from the client to a file using the `--record`
option. option.
* Mini-webserver: wsproxy can detect and respond to normal web
requests on the same port as the WebSockets proxy and Flash security
policy. This functionality is activate with the `--web DIR` option
where DIR is the root of the web directory to serve.
* Wrap a program: see the "Wrap a Program" section below.
#### Implementations of wsproxy #### Implementations of wsproxy
There are three implementations of wsproxy: python, C, and Node There are three implementations of wsproxy: python, C, and Node
(node.js). wswrapper is only implemented in C. (node.js). wswrapper is only implemented in C.
Here is the feature support matrix for the the wsproxy implementations Here is the feature support matrix for the the wsproxy
and wswrapper: implementations:
<table> <table>
<tr> <tr>
<th>Program</th> <th>Program</th>
<th>Language</th> <th>Language</th>
<th>Proxy or Interposer</th>
<th>Multiprocess</th> <th>Multiprocess</th>
<th>Daemonize</th> <th>Daemonize</th>
<th>SSL/wss</th> <th>SSL/wss</th>
<th>Flash Policy Server</th> <th>Flash Policy Server</th>
<th>Session Record</th> <th>Session Record</th>
<th>Web Server</th> <th>Web Server</th>
<th>Program Wrap</th>
</tr> <tr> </tr> <tr>
<td>wsproxy.py</td> <td>wsproxy.py</td>
<td>python</td> <td>python</td>
<td>proxy</td>
<td>yes</td> <td>yes</td>
<td>yes</td> <td>yes</td>
<td>yes 1</td> <td>yes 1</td>
<td>yes</td> <td>yes</td>
<td>yes</td> <td>yes</td>
<td>yes</td> <td>yes</td>
<td>yes</td>
</tr> <tr> </tr> <tr>
<td>wsproxy</td> <td>wsproxy</td>
<td>C</td> <td>C</td>
<td>proxy</td>
<td>yes</td> <td>yes</td>
<td>yes</td> <td>yes</td>
<td>yes</td> <td>yes</td>
<td>yes</td> <td>yes</td>
<td>no</td> <td>no</td>
<td>no</td> <td>no</td>
<td>no</td>
</tr> </tr>
</tr> <tr> </tr> <tr>
<td>wsproxy.js</td> <td>wsproxy.js</td>
<td>Node (node.js)</td> <td>Node (node.js)</td>
<td>proxy</td>
<td>yes</td> <td>yes</td>
<td>no</td> <td>no</td>
<td>no</td> <td>no</td>
<td>no</td> <td>no</td>
<td>no</td> <td>no</td>
<td>no</td> <td>no</td>
</tr>
</tr> <tr>
<td>wswrap/wswrapper.so</td>
<td>shell/C</td>
<td>interposer</td>
<td>indirectly</td>
<td>indirectly</td>
<td>no</td>
<td>no</td>
<td>no</td>
<td>no</td> <td>no</td>
</tr> </tr>
</table> </table>
...@@ -120,6 +103,42 @@ and wswrapper: ...@@ -120,6 +103,42 @@ and wswrapper:
section on *Building the Python ssl module*. section on *Building the Python ssl module*.
### Wrap a Program
In addition to proxying from a source address to a target address
(which may be on a different system), wsproxy has the ability to
launch a program on the local system and proxy WebSockets traffic to
a normal TCP port owned/bound by the program.
The is accomplished with a small LD_PRELOAD library (`rebind.so`)
which intercepts bind() system calls by the program. The specified
port is moved to a new localhost/loopback free high port. wsproxy
then proxies WebSockets traffic directed to the original port to the
new (moved) port of the program.
The program wrap mode is invoked by replacing the target with `--`
followed by the program command line to wrap.
`./utils/wsproxy.py 2023 -- PROGRAM ARGS`
The `--wrap-mode` option can be used to indicate what action to take
when the wrapped program exits or daemonizes.
Here is an example of using wsproxy to wrap the vncserver command
(which backgrounds itself):
`./utils/wsproxy.py 5901 --wrap-mode=ignore -- vncserver -geometry 1024x768 :1`
Here is an example of wrapping telnetd (from krb5-telnetd).telnetd
exits after the connection closes so the wrap mode is set to respawn
the command:
`sudo ./utils/wsproxy.py 2023 --wrap-mode=respawn -- telnetd -debug 2023`
The `utils/wstelnet.html` page demonstrates a simple WebSockets based
telnet client.
### Building the Python ssl module (for python 2.5 and older) ### Building the Python ssl module (for python 2.5 and older)
* Install the build dependencies. On Ubuntu use this command: * Install the build dependencies. On Ubuntu use this command:
......
utils/VT100.js 0 → 120000
View file @ f2538f33
VT100-orig.js
\ No newline at end of file
utils/include 0 → 120000
View file @ f2538f33
../include
\ No newline at end of file
utils/launch.sh
View file @ f2538f33
...@@ -7,10 +7,10 @@ usage() { ...@@ -7,10 +7,10 @@ usage() {
fi fi
echo "Usage: ${NAME} [--listen PORT] [--vnc VNC_HOST:PORT] [--cert CERT]" echo "Usage: ${NAME} [--listen PORT] [--vnc VNC_HOST:PORT] [--cert CERT]"
echo echo
echo "Starts a mini-webserver and the WebSockets proxy and" echo "Starts the WebSockets proxy and a mini-webserver and "
echo "provides a cut and paste URL to go to." echo "provides a cut-and-paste URL to go to."
echo echo
echo " --listen PORT Port for webserver/proxy to listen on" echo " --listen PORT Port for proxy/webserver to listen on"
echo " Default: 6080" echo " Default: 6080"
echo " --vnc VNC_HOST:PORT VNC server host:port proxy target" echo " --vnc VNC_HOST:PORT VNC server host:port proxy target"
echo " Default: localhost:5900" echo " Default: localhost:5900"
...@@ -92,12 +92,10 @@ else ...@@ -92,12 +92,10 @@ else
fi fi
echo "Starting webserver and WebSockets proxy on port ${PORT}" echo "Starting webserver and WebSockets proxy on port ${PORT}"
${HERE}/wsproxy.py -f --web ${WEB} ${CERT:+--cert ${CERT}} ${PORT} ${VNC_DEST} & ${HERE}/wsproxy.py --web ${WEB} ${CERT:+--cert ${CERT}} ${PORT} ${VNC_DEST} &
proxy_pid="$!" proxy_pid="$!"
sleep 1 sleep 1
if ps -p ${proxy_pid} >/dev/null; then if ! ps -p ${proxy_pid} >/dev/null; then
echo "Started WebSockets proxy (pid: ${proxy_pid})"
else
proxy_pid= proxy_pid=
echo "Failed to start WebSockets proxy" echo "Failed to start WebSockets proxy"
exit 1 exit 1
......
utils/rebind 0 → 100755
View file @ f2538f33
#!/bin/bash
usage() {
echo "Usage: $(basename $0) OLD_PORT NEW_PORT COMMAND_LINE"
echo
echo "Launch COMMAND_LINE, but intercept system calls to bind"
echo "to OLD_PORT and instead bind them to localhost:NEW_PORT"
exit 2
}
# Parameter defaults
mydir=$(readlink -f $(dirname ${0}))
export REBIND_PORT_OLD="${1}"; shift
export REBIND_PORT_NEW="${1}"; shift
LD_PRELOAD=${mydir}/rebind.so "${@}"
utils/rebind.c 0 → 100644
View file @ f2538f33
/*
* rebind: Intercept bind calls and bind to a different port
* Copyright 2010 Joel Martin
* Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
*
* Overload (LD_PRELOAD) bind system call. If REBIND_PORT_OLD and
* REBIND_PORT_NEW environment variables are set then bind on the new
* port (of localhost) instead of the old port.
*
* This allows a proxy (such as wsproxy) to run on the old port and translate
* traffic to/from the new port.
*
* Usage:
* LD_PRELOAD=./rebind.so \
* REBIND_PORT_OLD=23 \
* REBIND_PORT_NEW=2023 \
* program
*/
//#define DO_DEBUG 1
#include <stdio.h>
#include <stdlib.h>
#define __USE_GNU 1 // Pull in RTLD_NEXT
#include <dlfcn.h>
#include <string.h>
#include <netinet/in.h>
#if defined(DO_DEBUG)
#define DEBUG(...) \
fprintf(stderr, "wswrapper: "); \
fprintf(stderr, __VA_ARGS__);
#else
#define DEBUG(...)
#endif
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
static void * (*func)();
int do_move = 0;
struct sockaddr_in * addr_in = (struct sockaddr_in *)addr;
struct sockaddr_in addr_tmp;
socklen_t addrlen_tmp;
char * PORT_OLD, * PORT_NEW, * end1, * end2;
int ret, oldport, newport, askport = htons(addr_in->sin_port);
uint32_t askaddr = htons(addr_in->sin_addr.s_addr);
if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "bind");
DEBUG(">> bind(%d, _, %d), askaddr %d, askport %d\n",
sockfd, addrlen, askaddr, askport);
/* Determine if we should move this socket */
if (addr_in->sin_family == AF_INET) {
// TODO: support IPv6
PORT_OLD = getenv("REBIND_OLD_PORT");
PORT_NEW = getenv("REBIND_NEW_PORT");
if (PORT_OLD && (*PORT_OLD != '\0') &&
PORT_NEW && (*PORT_NEW != '\0')) {
oldport = strtol(PORT_OLD, &end1, 10);
newport = strtol(PORT_NEW, &end2, 10);
if (oldport && (*end1 == '\0') &&
newport && (*end2 == '\0') &&
(oldport == askport)) {
do_move = 1;
}
}
}
if (! do_move) {
/* Just pass everything right through to the real bind */
ret = (int) func(sockfd, addr, addrlen);
DEBUG("<< bind(%d, _, %d) ret %d\n", sockfd, addrlen, ret);
return ret;
}
DEBUG("binding fd %d on localhost:%d instead of 0x%x:%d\n",
sockfd, newport, ntohl(addr_in->sin_addr.s_addr), oldport);
/* Use a temporary location for the new address information */
addrlen_tmp = sizeof(addr_tmp);
memcpy(&addr_tmp, addr, addrlen_tmp);
/* Bind to other port on the loopback instead */
addr_tmp.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr_tmp.sin_port = htons(newport);
ret = (int) func(sockfd, &addr_tmp, addrlen_tmp);
DEBUG("<< bind(%d, _, %d) ret %d\n", sockfd, addrlen, ret);
return ret;
}
utils/websocket.py
View file @ f2538f33
...@@ -11,7 +11,7 @@ as taken from http://docs.python.org/dev/library/ssl.html#certificates ...@@ -11,7 +11,7 @@ as taken from http://docs.python.org/dev/library/ssl.html#certificates
''' '''
import sys, socket, ssl, struct, traceback import sys, socket, ssl, struct, traceback, select
import os, resource, errno, signal # daemonizing import os, resource, errno, signal # daemonizing
from SimpleHTTPServer import SimpleHTTPRequestHandler from SimpleHTTPServer import SimpleHTTPRequestHandler
from cStringIO import StringIO from cStringIO import StringIO
...@@ -26,7 +26,7 @@ from cgi import parse_qsl ...@@ -26,7 +26,7 @@ from cgi import parse_qsl
class WebSocketServer(): class WebSocketServer():
""" """
WebSockets server class. WebSockets server class.
Must be sub-classed with handler method definition. Must be sub-classed with new_client method definition.
""" """
server_handshake = """HTTP/1.1 101 Web Socket Protocol Handshake\r server_handshake = """HTTP/1.1 101 Web Socket Protocol Handshake\r
...@@ -70,6 +70,21 @@ Connection: Upgrade\r ...@@ -70,6 +70,21 @@ Connection: Upgrade\r
self.handler_id = 1 self.handler_id = 1
print "WebSocket server settings:"
print " - Listen on %s:%s" % (
self.listen_host, self.listen_port)
print " - Flash security policy server"
if self.web:
print " - Web server"
if os.path.exists(self.cert):
print " - SSL/TLS support"
if self.ssl_only:
print " - Deny non-SSL/TLS connections"
else:
print " - No SSL/TLS support (no cert file)"
if self.daemon:
print " - Backgrounding (daemon)"
# #
# WebSocketServer static methods # WebSocketServer static methods
# #
...@@ -284,16 +299,34 @@ Connection: Upgrade\r ...@@ -284,16 +299,34 @@ Connection: Upgrade\r
return retsock return retsock
def handler(self, client): #
# Events that can/should be overridden in sub-classes
#
def started(self):
""" Called after WebSockets startup """
self.vmsg("WebSockets server started")
def poll(self):
""" Run periodically while waiting for connections. """
self.msg("Running poll()")
def do_SIGCHLD(self, sig, stack):
self.vmsg("Got SIGCHLD, ignoring")
def do_SIGINT(self, sig, stack):
self.msg("Got SIGINT, exiting")
sys.exit(0)
def new_client(self, client):
""" Do something with a WebSockets client connection. """ """ Do something with a WebSockets client connection. """
raise("WebSocketServer.handler() must be overloaded") raise("WebSocketServer.new_client() must be overloaded")
def start_server(self): def start_server(self):
""" """
Daemonize if requested. Listen for for connections. Run Daemonize if requested. Listen for for connections. Run
do_handshake() method for each connection. If the connection do_handshake() method for each connection. If the connection
is a WebSockets client then call handler() method (which must is a WebSockets client then call new_client() method (which must
be overridden) for each connection. be overridden) for each new client connection.
""" """
lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
...@@ -301,37 +334,46 @@ Connection: Upgrade\r ...@@ -301,37 +334,46 @@ Connection: Upgrade\r
lsock.bind((self.listen_host, self.listen_port)) lsock.bind((self.listen_host, self.listen_port))
lsock.listen(100) lsock.listen(100)
print "WebSocket server settings:"
print " - Listening on %s:%s" % (
self.listen_host, self.listen_port)
if self.daemon:
print " - Backgrounding (daemon)"
print " - Flash security policy server"
if self.web:
print " - Web server"
if os.path.exists(self.cert):
print " - SSL/TLS support"
if self.ssl_only:
print " - Deny non-SSL/TLS connections"
if self.daemon: if self.daemon:
self.daemonize(self, keepfd=lsock.fileno()) self.daemonize(self, keepfd=lsock.fileno())
self.started() # Some things need to happen after daemonizing
# Reep zombies # Reep zombies
signal.signal(signal.SIGCHLD, signal.SIG_IGN) signal.signal(signal.SIGCHLD, self.do_SIGCHLD)
signal.signal(signal.SIGINT, self.do_SIGINT)
while True: while True:
try: try:
csock = startsock = None csock = startsock = None
pid = 0 pid = err = 0
try:
self.poll()
ready = select.select([lsock], [], [], 1)[0];
if lsock in ready:
startsock, address = lsock.accept() startsock, address = lsock.accept()
else:
continue
except Exception, exc:
if hasattr(exc, 'errno'):
err = exc.errno
elif type(exc) == select.error:
err = exc[0]
if err == errno.EINTR:
self.vmsg("Ignoring interrupted syscall()")
continue
else:
raise
self.vmsg('%s: forking handler' % address[0]) self.vmsg('%s: forking handler' % address[0])
pid = os.fork() pid = os.fork()
if pid == 0: if pid == 0:
# handler process # handler process
csock = self.do_handshake(startsock, address) csock = self.do_handshake(startsock, address)
self.handler(csock) self.new_client(csock)
else: else:
# parent process # parent process
self.handler_id += 1 self.handler_id += 1
......
utils/wsecho.py 0 → 100755
View file @ f2538f33
#!/usr/bin/python
'''
A WebSocket server that echos back whatever it receives from the client.
Copyright 2010 Joel Martin
Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
You can make a cert/key with openssl using:
openssl req -new -x509 -days 365 -nodes -out self.pem -keyout self.pem
as taken from http://docs.python.org/dev/library/ssl.html#certificates
'''
import sys, socket, select
from websocket import WebSocketServer
class WebSocketEcho(WebSocketServer):
"""
WebSockets server that echo back whatever is received from the
client. All traffic to/from the client is base64
encoded/decoded.
"""
buffer_size = 8096
def new_client(self, client):
"""
Echo back whatever is received.
"""
cqueue = []
cpartial = ""
rlist = [client]
while True:
wlist = []
if cqueue: wlist.append(client)
ins, outs, excepts = select.select(rlist, wlist, [], 1)
if excepts: raise Exception("Socket exception")
if client in outs:
# Send queued target data to the client
dat = cqueue.pop(0)
sent = client.send(dat)
self.vmsg("Sent %s/%s bytes of frame: '%s'" % (
sent, len(dat), self.decode(dat)[0]))
if sent != len(dat):
# requeue the remaining data
cqueue.insert(0, dat[sent:])
if client in ins:
# Receive client data, decode it, and send it back
buf = client.recv(self.buffer_size)
if len(buf) == 0: raise self.EClose("Client closed")
if buf == '\xff\x00':
raise self.EClose("Client sent orderly close frame")
elif buf[-1] == '\xff':
if cpartial:
# Prepend saved partial and decode frame(s)
frames = self.decode(cpartial + buf)
cpartial = ""
else:
# decode frame(s)
frames = self.decode(buf)
for frame in frames:
self.vmsg("Received frame: %s" % repr(frame))
cqueue.append(self.encode(frame))
else:
# Save off partial WebSockets frame
self.vmsg("Received partial frame")
cpartial = cpartial + buf
if __name__ == '__main__':
try:
if len(sys.argv) < 1: raise
listen_port = int(sys.argv[1])
except:
print "Usage: %s <listen_port>" % sys.argv[0]
sys.exit(1)
server = WebSocketEcho(
listen_port=listen_port,
verbose=True,
cert='self.pem',
web='.')
server.start_server()
utils/wsproxy.c
View file @ f2538f33
...@@ -34,7 +34,7 @@ Traffic Legend:\n\ ...@@ -34,7 +34,7 @@ Traffic Legend:\n\
char USAGE[] = "Usage: [options] " \ char USAGE[] = "Usage: [options] " \
"[source_addr:]source_port target_addr:target_port\n\n" \ "[source_addr:]source_port target_addr:target_port\n\n" \
" --verbose|-v verbose messages and per frame traffic\n" \ " --verbose|-v verbose messages and per frame traffic\n" \
" --foreground|-f stay in foreground, do not daemonize\n" \ " --daemon|-D become a daemon (background process)\n" \
" --cert CERT SSL certificate file\n" \ " --cert CERT SSL certificate file\n" \
" --key KEY SSL key file (if separate from cert)\n" \ " --key KEY SSL key file (if separate from cert)\n" \
" --ssl-only disallow non-encrypted connections"; " --ssl-only disallow non-encrypted connections";
...@@ -244,12 +244,12 @@ void proxy_handler(ws_ctx_t *ws_ctx) { ...@@ -244,12 +244,12 @@ void proxy_handler(ws_ctx_t *ws_ctx) {
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
int fd, c, option_index = 0; int fd, c, option_index = 0;
static int ssl_only = 0, foreground = 0, verbose = 0; static int ssl_only = 0, daemon = 0, verbose = 0;
char *found; char *found;
static struct option long_options[] = { static struct option long_options[] = {
{"verbose", no_argument, &verbose, 'v'}, {"verbose", no_argument, &verbose, 'v'},
{"ssl-only", no_argument, &ssl_only, 1 }, {"ssl-only", no_argument, &ssl_only, 1 },
{"foreground", no_argument, &foreground, 'f'}, {"daemon", no_argument, &daemon, 'D'},
/* ---- */ /* ---- */
{"cert", required_argument, 0, 'c'}, {"cert", required_argument, 0, 'c'},
{"key", required_argument, 0, 'k'}, {"key", required_argument, 0, 'k'},
...@@ -264,7 +264,7 @@ int main(int argc, char *argv[]) ...@@ -264,7 +264,7 @@ int main(int argc, char *argv[])
settings.key = ""; settings.key = "";
while (1) { while (1) {
c = getopt_long (argc, argv, "vfc:k:", c = getopt_long (argc, argv, "vDc:k:",
long_options, &option_index); long_options, &option_index);
/* Detect the end */ /* Detect the end */
...@@ -278,8 +278,8 @@ int main(int argc, char *argv[]) ...@@ -278,8 +278,8 @@ int main(int argc, char *argv[])
case 'v': case 'v':
verbose = 1; verbose = 1;
break; break;
case 'f': case 'D':
foreground = 1; daemon = 1;
break; break;
case 'c': case 'c':
settings.cert = realpath(optarg, NULL); settings.cert = realpath(optarg, NULL);
...@@ -299,7 +299,7 @@ int main(int argc, char *argv[]) ...@@ -299,7 +299,7 @@ int main(int argc, char *argv[])
} }
settings.verbose = verbose; settings.verbose = verbose;
settings.ssl_only = ssl_only; settings.ssl_only = ssl_only;
settings.daemon = foreground ? 0: 1; settings.daemon = daemon;
if ((argc-optind) != 2) { if ((argc-optind) != 2) {
usage("Invalid number of arguments\n"); usage("Invalid number of arguments\n");
......
utils/wsproxy.py
View file @ f2538f33
...@@ -11,7 +11,7 @@ as taken from http://docs.python.org/dev/library/ssl.html#certificates ...@@ -11,7 +11,7 @@ as taken from http://docs.python.org/dev/library/ssl.html#certificates
''' '''
import socket, optparse, time, os import socket, optparse, time, os, sys, subprocess
from select import select from select import select
from websocket import WebSocketServer from websocket import WebSocketServer
...@@ -38,12 +38,102 @@ Traffic Legend: ...@@ -38,12 +38,102 @@ Traffic Legend:
""" """
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
# Save off the target host:port # Save off proxy specific options
self.target_host = kwargs.pop('target_host') self.target_host = kwargs.pop('target_host')
self.target_port = kwargs.pop('target_port') self.target_port = kwargs.pop('target_port')
self.wrap_cmd = kwargs.pop('wrap_cmd')
self.wrap_mode = kwargs.pop('wrap_mode')
# Last 3 timestamps command was run
self.wrap_times = [0, 0, 0]
if self.wrap_cmd:
rebinder_path = ['./', os.path.dirname(sys.argv[0])]
self.rebinder = None
for rdir in rebinder_path:
rpath = os.path.join(rdir, "rebind.so")
if os.path.exists(rpath):
self.rebinder = rpath
break
if not self.rebinder:
raise Exception("rebind.so not found, perhaps you need to run make")
self.target_host = "127.0.0.1" # Loopback
# Find a free high port
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('', 0))
self.target_port = sock.getsockname()[1]
sock.close()
os.environ.update({
"LD_PRELOAD": self.rebinder,
"REBIND_OLD_PORT": str(kwargs['listen_port']),
"REBIND_NEW_PORT": str(self.target_port)})
WebSocketServer.__init__(self, *args, **kwargs) WebSocketServer.__init__(self, *args, **kwargs)
def handler(self, client): def run_wrap_cmd(self):
print "Starting '%s'" % " ".join(self.wrap_cmd)
self.wrap_times.append(time.time())
self.wrap_times.pop(0)
self.cmd = subprocess.Popen(
self.wrap_cmd, env=os.environ)
self.spawn_message = True
def started(self):
"""
Called after Websockets server startup (i.e. after daemonize)
"""
# Need to call wrapped command after daemonization so we can
# know when the wrapped command exits
if self.wrap_cmd:
print " - proxying from %s:%s to '%s' (port %s)\n" % (
self.listen_host, self.listen_port,
" ".join(self.wrap_cmd), self.target_port)
self.run_wrap_cmd()
else:
print " - proxying from %s:%s to %s:%s\n" % (
self.listen_host, self.listen_port,
self.target_host, self.target_port)
def poll(self):
# If we are wrapping a command, check it's status
if self.wrap_cmd and self.cmd:
ret = self.cmd.poll()
if ret != None:
self.vmsg("Wrapped command exited (or daemon). Returned %s" % ret)
self.cmd = None
if self.wrap_cmd and self.cmd == None:
# Response to wrapped command being gone
if self.wrap_mode == "ignore":
pass
elif self.wrap_mode == "exit":
sys.exit(ret)
elif self.wrap_mode == "respawn":
now = time.time()
avg = sum(self.wrap_times)/len(self.wrap_times)
if (now - avg) < 10:
# 3 times in the last 10 seconds
if self.spawn_message:
print "Command respawning too fast"
self.spawn_message = False
else:
self.run_wrap_cmd()
#
# Routines above this point are run in the master listener
# process.
#
#
# Routines below this point are connection handler routines and
# will be run in a separate forked process for each connection.
#
def new_client(self, client):
""" """
Called after a new WebSocket connection has been established. Called after a new WebSocket connection has been established.
""" """
...@@ -155,16 +245,18 @@ Traffic Legend: ...@@ -155,16 +245,18 @@ Traffic Legend:
cpartial = cpartial + buf cpartial = cpartial + buf
if __name__ == '__main__': if __name__ == '__main__':
usage = "%prog [--record FILE]" usage = "\n %prog [options]"
usage += " [source_addr:]source_port target_addr:target_port" usage += " [source_addr:]source_port target_addr:target_port"
usage += "\n %prog [options]"
usage += " [source_addr:]source_port -- WRAP_COMMAND_LINE"
parser = optparse.OptionParser(usage=usage) parser = optparse.OptionParser(usage=usage)
parser.add_option("--verbose", "-v", action="store_true", parser.add_option("--verbose", "-v", action="store_true",
help="verbose messages and per frame traffic") help="verbose messages and per frame traffic")
parser.add_option("--record", parser.add_option("--record",
help="record sessions to FILE.[session_number]", metavar="FILE") help="record sessions to FILE.[session_number]", metavar="FILE")
parser.add_option("--foreground", "-f", parser.add_option("--daemon", "-D",
dest="daemon", default=True, action="store_false", dest="daemon", action="store_true",
help="stay in foreground, do not daemonize") help="become a daemon (background process)")
parser.add_option("--cert", default="self.pem", parser.add_option("--cert", default="self.pem",
help="SSL certificate file") help="SSL certificate file")
parser.add_option("--key", default=None, parser.add_option("--key", default=None,
...@@ -173,28 +265,41 @@ if __name__ == '__main__': ...@@ -173,28 +265,41 @@ if __name__ == '__main__':
help="disallow non-encrypted connections") help="disallow non-encrypted connections")
parser.add_option("--web", default=None, metavar="DIR", parser.add_option("--web", default=None, metavar="DIR",
help="run webserver on same port. Serve files from DIR.") help="run webserver on same port. Serve files from DIR.")
parser.add_option("--wrap-mode", default="exit", metavar="MODE",
choices=["exit", "ignore", "respawn"],
help="action to take when the wrapped program exits "
"or daemonizes: exit (default), ignore, respawn")
(opts, args) = parser.parse_args() (opts, args) = parser.parse_args()
# Sanity checks # Sanity checks
if len(args) > 2: parser.error("Too many arguments") if len(args) < 2:
if len(args) < 2: parser.error("Too few arguments") parser.error("Too few arguments")
if sys.argv.count('--'):
opts.wrap_cmd = args[1:]
else:
opts.wrap_cmd = None
if len(args) > 2:
parser.error("Too many arguments")
if opts.ssl_only and not os.path.exists(opts.cert): if opts.ssl_only and not os.path.exists(opts.cert):
parser.error("SSL only and %s not found" % opts.cert) parser.error("SSL only and %s not found" % opts.cert)
elif not os.path.exists(opts.cert):
print "Warning: %s not found" % opts.cert
# Parse host:port and convert ports to numbers # Parse host:port and convert ports to numbers
if args[0].count(':') > 0: if args[0].count(':') > 0:
opts.listen_host, opts.listen_port = args[0].split(':') opts.listen_host, opts.listen_port = args[0].split(':')
else: else:
opts.listen_host, opts.listen_port = '', args[0] opts.listen_host, opts.listen_port = '', args[0]
try: opts.listen_port = int(opts.listen_port)
except: parser.error("Error parsing listen port")
if opts.wrap_cmd:
opts.target_host = None
opts.target_port = None
else:
if args[1].count(':') > 0: if args[1].count(':') > 0:
opts.target_host, opts.target_port = args[1].split(':') opts.target_host, opts.target_port = args[1].split(':')
else: else:
parser.error("Error parsing target") parser.error("Error parsing target")
try: opts.listen_port = int(opts.listen_port)
except: parser.error("Error parsing listen port")
try: opts.target_port = int(opts.target_port) try: opts.target_port = int(opts.target_port)
except: parser.error("Error parsing target port") except: parser.error("Error parsing target port")
......
utils/wstelnet.html 0 → 100644
View file @ f2538f33
<html>
<head>
<title>WebSockets Telnet</title>
<script src="include/base64.js"></script>
<script src="include/util.js"></script>
<script src="include/webutil.js"></script>
<script src="include/canvas.js"></script>
<script src="VT100.js"></script>
<script src="wstelnet.js"></script>
<!-- Uncomment to activate firebug lite -->
<!--
<script type='text/javascript'
src='http://getfirebug.com/releases/lite/1.2/firebug-lite-compressed.js'></script>
-->
</head>
<body>
Host: <input id='host' style='width:100'>&nbsp;
Port: <input id='port' style='width:50'>&nbsp;
Encrypt: <input id='encrypt' type='checkbox'>&nbsp;
<input id='connectButton' type='button' value='Connect' style='width:100px'
onclick="connect();">&nbsp;
<br><br>
<pre id="terminal"></pre>
<script>
var telnet;
function connect() {
telnet.connect($D('host').value,
$D('port').value,
$D('encrypt').checked);
$D('connectButton').disabled = true;
$D('connectButton').value = "Connecting";
}
function disconnect() {
$D('connectButton').disabled = true;
$D('connectButton').value = "Disconnecting";
telnet.disconnect();
}
function connected() {
$D('connectButton').disabled = false;
$D('connectButton').value = "Disconnect";
$D('connectButton').onclick = disconnect;
}
function disconnected() {
$D('connectButton').disabled = false;
$D('connectButton').value = "Connect";
$D('connectButton').onclick = connect;
}
/* If no builtin websockets then load web_socket.js */
if (window.WebSocket) {
VNC_native_ws = true;
} else {
VNC_native_ws = false;
console.log("Loading web-socket-js flash bridge");
var extra = "<script src='include/web-socket-js/swfobject.js'><\/script>";
extra += "<script src='include/web-socket-js/FABridge.js'><\/script>";
extra += "<script src='include/web-socket-js/web_socket.js'><\/script>";
document.write(extra);
}
window.onload = function() {
console.log("onload");
if (!VNC_native_ws) {
console.log("initializing web-socket-js flash bridge");
WebSocket.__swfLocation = "include/web-socket-js/WebSocketMain.swf";
WebSocket.__initialize();
}
var url = document.location.href;
$D('host').value = (url.match(/host=([^&#]*)/) || ['',''])[1];
$D('port').value = (url.match(/port=([^&#]*)/) || ['',''])[1];
telnet = Telnet('terminal', connected, disconnected);
}
</script>
</body>
</html>
utils/wstelnet.js 0 → 100644
View file @ f2538f33
/*
* WebSockets telnet client
* Copyright (C) 2011 Joel Martin
* Licensed under LGPL-3 (see LICENSE.txt)
*
* Incorporates VT100.js from:
* http://code.google.com/p/sshconsole
* Which was modified from:
* http://fzort.org/bi/o.php#vt100_js
*
* Telnet protocol:
* http://www.networksorcery.com/enp/protocol/telnet.htm
* http://www.networksorcery.com/enp/rfc/rfc1091.txt
*
* ANSI escape sequeneces:
* http://en.wikipedia.org/wiki/ANSI_escape_code
* http://ascii-table.com/ansi-escape-sequences-vt-100.php
* http://www.termsys.demon.co.uk/vtansi.htm
* http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
*
* ASCII codes:
* http://en.wikipedia.org/wiki/ASCII
* http://www.hobbyprojects.com/ascii-table/ascii-table.html
*
* Other web consoles:
* http://stackoverflow.com/questions/244750/ajax-console-window-with-ansi-vt100-support
*/
function Telnet(target, connect_callback, disconnect_callback) {
var that = {}, // Public API interface
vt100, ws, sQ = [];
termType = "VT100";
Array.prototype.pushStr = function (str) {
var n = str.length;
for (var i=0; i < n; i++) {
this.push(str.charCodeAt(i));
}
}
function do_send() {
if (sQ.length > 0) {
Util.Debug("Sending " + sQ);
ws.send(Base64.encode(sQ));
sQ = [];
}
}
function do_recv(e) {
//console.log(">> do_recv");
var arr = Base64.decode(e.data), str = "",
chr, cmd, code, value;
Util.Debug("Received array '" + arr + "'");
while (arr.length > 0) {
chr = arr.shift();
switch (chr) {
case 255: // IAC
cmd = chr;
code = arr.shift();
value = arr.shift();
switch (code) {
case 254: // DONT
Util.Debug("Got Cmd DONT '" + value + "', ignoring");
break;
case 253: // DO
Util.Debug("Got Cmd DO '" + value + "'");
if (value === 24) {
// Terminal type
Util.Info("Send WILL '" + value + "' (TERM-TYPE)");
sQ.push(255, 251, value);
} else {
// Refuse other DO requests with a WONT
Util.Debug("Send WONT '" + value + "'");
sQ.push(255, 252, value);
}
break;
case 252: // WONT
Util.Debug("Got Cmd WONT '" + value + "', ignoring");
break;
case 251: // WILL
Util.Debug("Got Cmd WILL '" + value + "'");
if (value === 1) {
// Affirm echo with DO
Util.Info("Send Cmd DO '" + value + "' (echo)");
sQ.push(255, 253, value);
} else {
// Reject other WILL offers with a DONT
Util.Debug("Send Cmd DONT '" + value + "'");
sQ.push(255, 254, value);
}
break;
case 250: // SB (subnegotiation)
if (value === 24) {
Util.Info("Got IAC SB TERM-TYPE SEND(1) IAC SE");
// TERM-TYPE subnegotiation
if (arr[0] === 1 &&
arr[1] === 255 &&
arr[2] === 240) {
arr.shift(); arr.shift(); arr.shift();
Util.Info("Send IAC SB TERM-TYPE IS(0) '" +
termType + "' IAC SE");
sQ.push(255, 250, 24, 0);
sQ.pushStr(termType);
sQ.push(255, 240);
} else {
Util.Info("Invalid subnegotiation received" + arr);
}
} else {
Util.Info("Ignoring SB " + value);
}
break;
default:
Util.Info("Got Cmd " + cmd + " " + value + ", ignoring"); }
continue;
case 242: // Data Mark (Synch)
cmd = chr;
code = arr.shift();
value = arr.shift();
Util.Info("Ignoring Data Mark (Synch)");
break;
default: // everything else
str += String.fromCharCode(chr);
}
}
if (sQ) {
do_send();
}
if (str) {
vt100.write(str);
}
//console.log("<< do_recv");
}
that.connect = function(host, port, encrypt) {
var host = host,
port = port,
scheme = "ws://", uri;
Util.Debug(">> connect");
if ((!host) || (!port)) {
console.log("must set host and port");
return;
}
if (ws) {
ws.close();
}
if (encrypt) {
scheme = "wss://";
}
uri = scheme + host + ":" + port;
Util.Info("connecting to " + uri);
ws = new WebSocket(uri);
ws.onmessage = do_recv;
ws.onopen = function(e) {
Util.Info(">> WebSockets.onopen");
vt100.curs_set(true, true);
connect_callback();
Util.Info("<< WebSockets.onopen");
};
ws.onclose = function(e) {
Util.Info(">> WebSockets.onclose");
that.disconnect();
Util.Info("<< WebSockets.onclose");
};
ws.onerror = function(e) {
Util.Info(">> WebSockets.onerror");
that.disconnect();
Util.Info("<< WebSockets.onerror");
};
Util.Debug("<< connect");
}
that.disconnect = function() {
Util.Debug(">> disconnect");
if (ws) {
ws.close();
}
vt100.curs_set(true, false);
disconnect_callback();
Util.Debug("<< disconnect");
}
function constructor() {
/* Initialize the terminal emulator/renderer */
vt100 = new VT100(80, 24, target);
// Turn off local echo
vt100.noecho();
/*
* Override VT100 I/O routines
*/
// Set handler for sending characters
vt100.getch(
function send_chr(chr, vt) {
var i;
Util.Debug(">> send_chr: " + chr);
for (i = 0; i < chr.length; i++) {
sQ.push(chr.charCodeAt(i));
}
do_send();
vt100.getch(send_chr);
}
);
vt100.debug = function(message) {
Util.Debug(message + "\n");
}
vt100.warn = function(message) {
Util.Warn(message + "\n");
}
vt100.curs_set = function(vis, grab, eventist)
{
this.debug("curs_set:: vis: " + vis + ", grab: " + grab);
if (vis !== undefined)
this.cursor_vis_ = (vis > 0);
if (eventist === undefined)
eventist = window;
if (grab === true || grab === false) {
if (grab === this.grab_events_)
return;
if (grab) {
this.grab_events_ = true;
VT100.the_vt_ = this;
Util.addEvent(eventist, 'keydown', vt100.key_down);
Util.addEvent(eventist, 'keyup', vt100.key_up);
} else {
Util.removeEvent(eventist, 'keydown', vt100.key_down);
Util.removeEvent(eventist, 'keyup', vt100.key_up);
this.grab_events_ = false;
VT100.the_vt_ = undefined;
}
}
}
vt100.key_down = function(e) {
var vt = VT100.the_vt_, keysym, ch, str = "";
if (vt === undefined)
return true;
keysym = getKeysym(e);
if (keysym < 128) {
if (e.ctrlKey) {
if (keysym == 64) {
// control 0
ch = 0;
} else if ((keysym >= 97) && (keysym <= 122)) {
// control codes 1-26
ch = keysym - 96;
} else if ((keysym >= 91) && (keysym <= 95)) {
// control codes 27-31
ch = keysym - 64;
} else {
Util.Info("Debug unknown control keysym: " + keysym);
}
} else {
ch = keysym;
}
str = String.fromCharCode(ch);
} else {
switch (keysym) {
case 65505: // Shift, do not send directly
break;
case 65507: // Ctrl, do not send directly
break;
case 65293: // Carriage return, line feed
str = '\n'; break;
case 65288: // Backspace
str = '\b'; break;
case 65307: // Escape
str = '\x1b'; break;
case 65361: // Left arrow
str = '\x1b[D'; break;
case 65362: // Up arrow
str = '\x1b[A'; break;
case 65363: // Right arrow
str = '\x1b[C'; break;
case 65364: // Down arrow
str = '\x1b[B'; break;
default:
Util.Info("Unrecoginized keysym " + keysym);
}
}
if (str) {
vt.key_buf_.push(str);
setTimeout(VT100.go_getch_, 0);
}
Util.stopEvent(e);
return false;
}
vt100.key_up = function(e) {
var vt = VT100.the_vt_;
if (vt === undefined)
return true;
Util.stopEvent(e);
return false;
}
return that;
}
return constructor(); // Return the public API interface
} // End of Telnet()
utils/wstest.py
View file @ f2538f33
...@@ -32,7 +32,7 @@ class WebSocketTest(WebSocketServer): ...@@ -32,7 +32,7 @@ class WebSocketTest(WebSocketServer):
WebSocketServer.__init__(self, *args, **kwargs) WebSocketServer.__init__(self, *args, **kwargs)
def handler(self, client): def new_client(self, client):
self.send_cnt = 0 self.send_cnt = 0
self.recv_cnt = 0 self.recv_cnt = 0
......
utils/wswrapper.c
View file @ f2538f33
...@@ -3,15 +3,27 @@ ...@@ -3,15 +3,27 @@
* Copyright 2010 Joel Martin * Copyright 2010 Joel Martin
* Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3) * Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
* *
* wswrapper.so is meant to be LD preloaded. Use wswrap to run a program using * wswrapper is an LD_PRELOAD library that converts a TCP listen socket of an
* wswrapper.so. * existing program to a be a WebSockets socket. The `wswrap` script can be
*/ * used to easily launch a program using wswrapper. Here is an example of
* using wswrapper with vncserver. wswrapper will convert the socket listening
/* * on port 5901 to be a WebSockets port:
* Limitations: *
* cd noVNC/utils
* ./wswrap 5901 vncserver -geometry 640x480 :1
*
* This is tricky a subtle process so there are some serious limitations:
* - multi-threaded programs may not work * - multi-threaded programs may not work
* - programs that fork may behave in strange and mysterious ways (such as
* fork bombing your system)
* - programs using ppoll or epoll will not work correctly * - programs using ppoll or epoll will not work correctly
* - doesn't support fopencookie, streams, putc, etc. * - doesn't support fopencookie, streams, putc, etc.
*
* **********************************************************************
* WARNING:
* Due to the above limitations, this code should be considered an experiment
* only. Consider using the program wrap mode of wsproxy.py instead.
* **********************************************************************
*/ */
#define DO_MSG 1 #define DO_MSG 1
...@@ -322,8 +334,8 @@ ssize_t _WS_ready(int sockfd, int nonblock) ...@@ -322,8 +334,8 @@ ssize_t _WS_ready(int sockfd, int nonblock)
while (1) { while (1) {
len = (int) rfunc(sockfd, buf, count, flags); len = (int) rfunc(sockfd, buf, count, flags);
if (len < 1) { if (len < 1) {
TRACE("<< _WS_ready(%d, %d) len < 1, errno: %d\n", TRACE("<< _WS_ready(%d, %d) len %d, errno: %d\n",
sockfd, nonblock, errno); sockfd, nonblock, len, errno);
return len; return len;
} }
if (len >= 2 && buf[0] == '\x00' && buf[1] == '\xff') { if (len >= 2 && buf[0] == '\x00' && buf[1] == '\xff') {
...@@ -668,7 +680,21 @@ int _WS_select(int mode, int nfds, fd_set *readfds, ...@@ -668,7 +680,21 @@ int _WS_select(int mode, int nfds, fd_set *readfds,
return ret; return ret;
} }
#ifdef DO_TRACE
TRACE(">> _WS_select(%d, %d, _, _, _, _)\n", mode, nfds); TRACE(">> _WS_select(%d, %d, _, _, _, _)\n", mode, nfds);
for (i = 0; i < _WS_nfds; i++) {
fd = _WS_fds[i];
if (readfds && (FD_ISSET(fd, readfds))) {
TRACE(" WS %d is in readfds\n", fd, nfds);
}
if (writefds && (FD_ISSET(fd, writefds))) {
TRACE(" WS %d is in writefds\n", fd, nfds);
}
if (exceptfds && (FD_ISSET(fd, exceptfds))) {
TRACE(" WS %d is in exceptfds\n", fd, nfds);
}
}
#endif
if (timeptr) { if (timeptr) {
memcpy(&savetv, timeptr, sizeof(savetv)); memcpy(&savetv, timeptr, sizeof(savetv));
gettimeofday(&starttv, NULL); gettimeofday(&starttv, NULL);
...@@ -763,12 +789,26 @@ int _WS_select(int mode, int nfds, fd_set *readfds, ...@@ -763,12 +789,26 @@ int _WS_select(int mode, int nfds, fd_set *readfds,
} while (ret == 0); } while (ret == 0);
/* Restore original time value for pselect glibc does */ /* Restore original time value for pselect glibc does */
if (mode == 1) { if (timeptr && mode == 1) {
memcpy(timeptr, &savetv, sizeof(savetv)); memcpy(timeptr, &savetv, sizeof(savetv));
} }
#ifdef DO_TRACE
TRACE("<< _WS_select(%d, %d, _, _, _, _) ret %d, errno %d\n", TRACE("<< _WS_select(%d, %d, _, _, _, _) ret %d, errno %d\n",
mode, nfds, ret, errno); mode, nfds, ret, errno);
for (i = 0; i < _WS_nfds; i++) {
fd = _WS_fds[i];
if (readfds && (FD_ISSET(fd, readfds))) {
TRACE(" WS %d is set in readfds\n", fd, nfds);
}
if (writefds && (FD_ISSET(fd, writefds))) {
TRACE(" WS %d is set in writefds\n", fd, nfds);
}
if (exceptfds && (FD_ISSET(fd, exceptfds))) {
TRACE(" WS %d is set in exceptfds\n", fd, nfds);
}
}
#endif
return ret; return ret;
} }
...@@ -1045,30 +1085,48 @@ int ppoll(struct pollfd *fds, nfds_t nfds, ...@@ -1045,30 +1085,48 @@ int ppoll(struct pollfd *fds, nfds_t nfds,
(sigset_t *)sigmask); (sigset_t *)sigmask);
} }
int dup(int oldfd) {
int ret;
static void * (*func)();
if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "dup");
TRACE(">> dup(%d) called\n", oldfd);
ret = (int) func(oldfd);
TRACE("<< dup(%d) ret %d\n", oldfd, ret);
return ret;
}
int dup2(int oldfd, int newfd) { int dup2(int oldfd, int newfd) {
int ret; int ret;
static void * (*func)(); static void * (*func)();
if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "dup2"); if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "dup2");
TRACE("dup2(%d, %d) called\n", oldfd, newfd); TRACE(">> dup2(%d, %d) called\n", oldfd, newfd);
ret = (int) func(oldfd, newfd); ret = (int) func(oldfd, newfd);
if (! _WS_connections[oldfd]) { if ((! _WS_connections[oldfd]) && (! _WS_connections[newfd])) {
return ret; return ret;
} }
if (ret < 0) { if ((ret < 0) || (oldfd == newfd) ||
(_WS_connections[oldfd] == _WS_connections[newfd])) {
TRACE("<< dup2(%d, %d) ret %d\n", oldfd, newfd, ret);
return ret; return ret;
} }
if (oldfd == newfd) {
return newfd;
}
/* dup2 behavior is to close newfd if it's open */ /* dup2 behavior is to close newfd if it's open */
if (_WS_connections[newfd]) { if (_WS_connections[newfd]) {
_WS_free(newfd); _WS_free(newfd);
} }
if (! _WS_connections[oldfd]) {
TRACE("<< dup2(%d, %d) ret %d\n", oldfd, newfd, ret);
return ret;
}
MSG("interposing on duplicated fd %d\n", newfd);
/* oldfd and newfd are now descriptors for the same socket, /* oldfd and newfd are now descriptors for the same socket,
* re-use the same context memory area */ * re-use the same context memory area */
_WS_connections[newfd] = _WS_connections[oldfd]; _WS_connections[newfd] = _WS_connections[oldfd];
...@@ -1078,6 +1136,21 @@ int dup2(int oldfd, int newfd) { ...@@ -1078,6 +1136,21 @@ int dup2(int oldfd, int newfd) {
_WS_fds[_WS_nfds] = newfd; _WS_fds[_WS_nfds] = newfd;
_WS_nfds++; _WS_nfds++;
TRACE("<< dup2(%d, %d) ret %d\n", oldfd, newfd, ret);
return ret; return ret;
} }
int dup3(int oldfd, int newfd, int flags) {
int ret;
static void * (*func)();
if (!func) func = (void *(*)()) dlsym(RTLD_NEXT, "dup3");
TRACE(">> dup3(%d, %d, %d) called\n", oldfd, newfd, flags);
ret = (int) func(oldfd, newfd, flags);
TRACE("<< dup3(%d, %d, %d) ret %d\n", oldfd, newfd, flags, ret);
return ret;
}
utils/wswrapper.h
View file @ f2538f33
...@@ -2,9 +2,6 @@ ...@@ -2,9 +2,6 @@
* wswrap/wswrapper: Add WebSockets support to any service. * wswrap/wswrapper: Add WebSockets support to any service.
* Copyright 2010 Joel Martin * Copyright 2010 Joel Martin
* Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3) * Licensed under LGPL version 3 (see docs/LICENSE.LGPL-3)
*
* wswrapper.so is meant to be LD preloaded. Use wswrap to run a program using
* wswrapper.so.
*/ */
#ifdef DO_MSG #ifdef DO_MSG
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment