2006-05-01 10:38:19 +00:00
|
|
|
/*
|
|
|
|
* QEMU VNC display driver
|
2007-09-16 21:08:06 +00:00
|
|
|
*
|
2006-05-01 10:38:19 +00:00
|
|
|
* Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
|
|
|
|
* Copyright (C) 2006 Fabrice Bellard
|
2009-03-06 20:27:13 +00:00
|
|
|
* Copyright (C) 2009 Red Hat, Inc
|
2007-09-16 21:08:06 +00:00
|
|
|
*
|
2006-05-01 10:38:19 +00:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2009-03-06 20:27:13 +00:00
|
|
|
#include "vnc.h"
|
2007-11-17 17:14:51 +00:00
|
|
|
#include "sysemu.h"
|
2006-04-30 22:53:25 +00:00
|
|
|
#include "qemu_socket.h"
|
2007-11-17 17:14:51 +00:00
|
|
|
#include "qemu-timer.h"
|
Support ACLs for controlling VNC access ("Daniel P. Berrange")
This patch introduces a generic internal API for access control lists
to be used by network servers in QEMU. It adds support for checking
these ACL in the VNC server, in two places. The first ACL is for the
SASL authentication mechanism, checking the SASL username. This ACL
is called 'vnc.username'. The second is for the TLS authentication
mechanism, when x509 client certificates are turned on, checking against
the Distinguished Name of the client. This ACL is called 'vnc.x509dname'
The internal API provides for an ACL with the following characteristics
- A unique name, eg vnc.username, and vnc.x509dname.
- A default policy, allow or deny
- An ordered series of match rules, with allow or deny policy
If none of the match rules apply, then the default policy is
used.
There is a monitor API to manipulate the ACLs, which I'll describe via
examples
(qemu) acl show vnc.username
policy: allow
(qemu) acl policy vnc.username denya
acl: policy set to 'deny'
(qemu) acl allow vnc.username fred
acl: added rule at position 1
(qemu) acl allow vnc.username bob
acl: added rule at position 2
(qemu) acl allow vnc.username joe 1
acl: added rule at position 1
(qemu) acl show vnc.username
policy: deny
0: allow fred
1: allow joe
2: allow bob
(qemu) acl show vnc.x509dname
policy: allow
(qemu) acl policy vnc.x509dname deny
acl: policy set to 'deny'
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=London,CN=*
acl: added rule at position 1
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=Boston,CN=bob
acl: added rule at position 2
(qemu) acl show vnc.x509dname
policy: deny
0: allow C=GB,O=ACME,L=London,CN=*
1: allow C=GB,O=ACME,L=Boston,CN=bob
By default the VNC server will not use any ACLs, allowing access to
the server if the user successfully authenticates. To enable use of
ACLs to restrict user access, the ',acl' flag should be given when
starting QEMU. The initial ACL activated will be a 'deny all' policy
and should be customized using monitor commands.
eg enable SASL auth and ACLs
qemu .... -vnc localhost:1,sasl,acl
The next patch will provide a way to load a pre-defined ACL when
starting up
Makefile | 6 +
b/acl.c | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
b/acl.h | 74 ++++++++++++++++++++++
configure | 18 +++++
monitor.c | 95 ++++++++++++++++++++++++++++
qemu-doc.texi | 49 ++++++++++++++
vnc-auth-sasl.c | 16 +++-
vnc-auth-sasl.h | 7 ++
vnc-tls.c | 19 +++++
vnc-tls.h | 3
vnc.c | 21 ++++++
vnc.h | 3
12 files changed, 491 insertions(+), 5 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6726 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:37 +00:00
|
|
|
#include "acl.h"
|
2009-12-10 19:16:10 +00:00
|
|
|
#include "qemu-objects.h"
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-08-03 09:56:01 +00:00
|
|
|
#define VNC_REFRESH_INTERVAL_BASE 30
|
|
|
|
#define VNC_REFRESH_INTERVAL_INC 50
|
|
|
|
#define VNC_REFRESH_INTERVAL_MAX 2000
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
#include "vnc_keysym.h"
|
2007-08-25 01:37:05 +00:00
|
|
|
#include "d3des.h"
|
|
|
|
|
2009-01-26 15:37:30 +00:00
|
|
|
#define count_bits(c, v) { \
|
|
|
|
for (c = 0; v; v >>= 1) \
|
|
|
|
{ \
|
|
|
|
c += v & 1; \
|
|
|
|
} \
|
|
|
|
}
|
2007-08-25 01:37:51 +00:00
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
static VncDisplay *vnc_display; /* needed for info vnc */
|
2009-01-15 22:14:11 +00:00
|
|
|
static DisplayChangeListener *dcl;
|
2007-02-05 20:20:30 +00:00
|
|
|
|
2009-03-06 20:27:05 +00:00
|
|
|
static char *addr_to_string(const char *format,
|
|
|
|
struct sockaddr_storage *sa,
|
|
|
|
socklen_t salen) {
|
|
|
|
char *addr;
|
|
|
|
char host[NI_MAXHOST];
|
|
|
|
char serv[NI_MAXSERV];
|
|
|
|
int err;
|
2009-03-13 15:03:27 +00:00
|
|
|
size_t addrlen;
|
2009-03-06 20:27:05 +00:00
|
|
|
|
|
|
|
if ((err = getnameinfo((struct sockaddr *)sa, salen,
|
|
|
|
host, sizeof(host),
|
|
|
|
serv, sizeof(serv),
|
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
|
|
|
|
VNC_DEBUG("Cannot resolve address %d: %s\n",
|
|
|
|
err, gai_strerror(err));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-03-13 15:03:27 +00:00
|
|
|
/* Enough for the existing format + the 2 vars we're
|
2009-06-06 15:00:31 +00:00
|
|
|
* substituting in. */
|
2009-03-13 15:03:27 +00:00
|
|
|
addrlen = strlen(format) + strlen(host) + strlen(serv);
|
|
|
|
addr = qemu_malloc(addrlen + 1);
|
|
|
|
snprintf(addr, addrlen, format, host, serv);
|
|
|
|
addr[addrlen] = '\0';
|
2009-03-06 20:27:05 +00:00
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
|
|
|
|
char *vnc_socket_local_addr(const char *format, int fd) {
|
2009-03-06 20:27:05 +00:00
|
|
|
struct sockaddr_storage sa;
|
|
|
|
socklen_t salen;
|
|
|
|
|
|
|
|
salen = sizeof(sa);
|
|
|
|
if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return addr_to_string(format, &sa, salen);
|
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
char *vnc_socket_remote_addr(const char *format, int fd) {
|
2009-03-06 20:27:05 +00:00
|
|
|
struct sockaddr_storage sa;
|
|
|
|
socklen_t salen;
|
|
|
|
|
|
|
|
salen = sizeof(sa);
|
|
|
|
if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return addr_to_string(format, &sa, salen);
|
|
|
|
}
|
|
|
|
|
2010-01-14 16:50:55 +00:00
|
|
|
static QString *get_sock_family(const struct sockaddr_storage *sa)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
switch (sa->ss_family)
|
|
|
|
{
|
|
|
|
case AF_INET:
|
|
|
|
name = "ipv4";
|
|
|
|
break;
|
|
|
|
case AF_INET6:
|
|
|
|
name = "ipv6";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
name = "unknown";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return qstring_from_str(name);
|
|
|
|
}
|
|
|
|
|
2009-12-10 19:16:10 +00:00
|
|
|
static int put_addr_qdict(QDict *qdict, struct sockaddr_storage *sa,
|
|
|
|
socklen_t salen)
|
|
|
|
{
|
|
|
|
char host[NI_MAXHOST];
|
|
|
|
char serv[NI_MAXSERV];
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if ((err = getnameinfo((struct sockaddr *)sa, salen,
|
|
|
|
host, sizeof(host),
|
|
|
|
serv, sizeof(serv),
|
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
|
|
|
|
VNC_DEBUG("Cannot resolve address %d: %s\n",
|
|
|
|
err, gai_strerror(err));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
qdict_put(qdict, "host", qstring_from_str(host));
|
|
|
|
qdict_put(qdict, "service", qstring_from_str(serv));
|
2010-01-14 16:50:55 +00:00
|
|
|
qdict_put(qdict, "family", get_sock_family(sa));
|
2009-12-10 19:16:10 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-14 16:50:53 +00:00
|
|
|
static int vnc_server_addr_put(QDict *qdict, int fd)
|
2009-12-10 19:16:10 +00:00
|
|
|
{
|
|
|
|
struct sockaddr_storage sa;
|
|
|
|
socklen_t salen;
|
|
|
|
|
|
|
|
salen = sizeof(sa);
|
|
|
|
if (getsockname(fd, (struct sockaddr*)&sa, &salen) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return put_addr_qdict(qdict, &sa, salen);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vnc_qdict_remote_addr(QDict *qdict, int fd)
|
|
|
|
{
|
|
|
|
struct sockaddr_storage sa;
|
|
|
|
socklen_t salen;
|
|
|
|
|
|
|
|
salen = sizeof(sa);
|
|
|
|
if (getpeername(fd, (struct sockaddr*)&sa, &salen) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return put_addr_qdict(qdict, &sa, salen);
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:05 +00:00
|
|
|
static const char *vnc_auth_name(VncDisplay *vd) {
|
|
|
|
switch (vd->auth) {
|
|
|
|
case VNC_AUTH_INVALID:
|
|
|
|
return "invalid";
|
|
|
|
case VNC_AUTH_NONE:
|
|
|
|
return "none";
|
|
|
|
case VNC_AUTH_VNC:
|
|
|
|
return "vnc";
|
|
|
|
case VNC_AUTH_RA2:
|
|
|
|
return "ra2";
|
|
|
|
case VNC_AUTH_RA2NE:
|
|
|
|
return "ra2ne";
|
|
|
|
case VNC_AUTH_TIGHT:
|
|
|
|
return "tight";
|
|
|
|
case VNC_AUTH_ULTRA:
|
|
|
|
return "ultra";
|
|
|
|
case VNC_AUTH_TLS:
|
|
|
|
return "tls";
|
|
|
|
case VNC_AUTH_VENCRYPT:
|
|
|
|
#ifdef CONFIG_VNC_TLS
|
|
|
|
switch (vd->subauth) {
|
|
|
|
case VNC_AUTH_VENCRYPT_PLAIN:
|
|
|
|
return "vencrypt+plain";
|
|
|
|
case VNC_AUTH_VENCRYPT_TLSNONE:
|
|
|
|
return "vencrypt+tls+none";
|
|
|
|
case VNC_AUTH_VENCRYPT_TLSVNC:
|
|
|
|
return "vencrypt+tls+vnc";
|
|
|
|
case VNC_AUTH_VENCRYPT_TLSPLAIN:
|
|
|
|
return "vencrypt+tls+plain";
|
|
|
|
case VNC_AUTH_VENCRYPT_X509NONE:
|
|
|
|
return "vencrypt+x509+none";
|
|
|
|
case VNC_AUTH_VENCRYPT_X509VNC:
|
|
|
|
return "vencrypt+x509+vnc";
|
|
|
|
case VNC_AUTH_VENCRYPT_X509PLAIN:
|
|
|
|
return "vencrypt+x509+plain";
|
2009-03-06 20:27:40 +00:00
|
|
|
case VNC_AUTH_VENCRYPT_TLSSASL:
|
|
|
|
return "vencrypt+tls+sasl";
|
|
|
|
case VNC_AUTH_VENCRYPT_X509SASL:
|
|
|
|
return "vencrypt+x509+sasl";
|
2009-03-06 20:27:05 +00:00
|
|
|
default:
|
|
|
|
return "vencrypt";
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
return "vencrypt";
|
|
|
|
#endif
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
case VNC_AUTH_SASL:
|
2009-03-06 20:27:40 +00:00
|
|
|
return "sasl";
|
2009-03-06 20:27:05 +00:00
|
|
|
}
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
|
2010-01-14 16:50:53 +00:00
|
|
|
static int vnc_server_info_put(QDict *qdict)
|
|
|
|
{
|
|
|
|
if (vnc_server_addr_put(qdict, vnc_display->lsock) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
qdict_put(qdict, "auth", qstring_from_str(vnc_auth_name(vnc_display)));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-14 16:50:56 +00:00
|
|
|
static void vnc_client_cache_auth(VncState *client)
|
2009-03-06 20:27:05 +00:00
|
|
|
{
|
2009-12-10 19:16:10 +00:00
|
|
|
QDict *qdict;
|
2009-03-06 20:27:05 +00:00
|
|
|
|
2010-01-14 16:50:56 +00:00
|
|
|
if (!client->info) {
|
|
|
|
return;
|
2009-12-10 19:16:10 +00:00
|
|
|
}
|
Include auth credentials in 'info vnc' ("Daniel P. Berrange")
This patch extends the 'info vnc' monitor output to include information
about the VNC client authentication credentials.
For clients authenticated using SASL, this will output the username.
For clients authenticated using x509 certificates, this will output
the x509 distinguished name.
Auth can be stacked, so both username & x509 dname may be shown.
Server:
address: 0.0.0.0:5902
auth: vencrypt+x509+sasl
Client:
address: 10.33.6.67:38621
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
Client:
address: 10.33.6.63:38620
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
vnc-tls.c | 17 +++++++++++++++++
vnc-tls.h | 3 +++
vnc.c | 19 +++++++++++++++++--
3 files changed, 37 insertions(+), 2 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6725 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:32 +00:00
|
|
|
|
2010-01-14 16:50:56 +00:00
|
|
|
qdict = qobject_to_qdict(client->info);
|
|
|
|
|
Include auth credentials in 'info vnc' ("Daniel P. Berrange")
This patch extends the 'info vnc' monitor output to include information
about the VNC client authentication credentials.
For clients authenticated using SASL, this will output the username.
For clients authenticated using x509 certificates, this will output
the x509 distinguished name.
Auth can be stacked, so both username & x509 dname may be shown.
Server:
address: 0.0.0.0:5902
auth: vencrypt+x509+sasl
Client:
address: 10.33.6.67:38621
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
Client:
address: 10.33.6.63:38620
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
vnc-tls.c | 17 +++++++++++++++++
vnc-tls.h | 3 +++
vnc.c | 19 +++++++++++++++++--
3 files changed, 37 insertions(+), 2 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6725 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:32 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
|
|
|
if (client->tls.session &&
|
2009-12-10 19:16:10 +00:00
|
|
|
client->tls.dname) {
|
|
|
|
qdict_put(qdict, "x509_dname", qstring_from_str(client->tls.dname));
|
|
|
|
}
|
Include auth credentials in 'info vnc' ("Daniel P. Berrange")
This patch extends the 'info vnc' monitor output to include information
about the VNC client authentication credentials.
For clients authenticated using SASL, this will output the username.
For clients authenticated using x509 certificates, this will output
the x509 distinguished name.
Auth can be stacked, so both username & x509 dname may be shown.
Server:
address: 0.0.0.0:5902
auth: vencrypt+x509+sasl
Client:
address: 10.33.6.67:38621
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
Client:
address: 10.33.6.63:38620
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
vnc-tls.c | 17 +++++++++++++++++
vnc-tls.h | 3 +++
vnc.c | 19 +++++++++++++++++--
3 files changed, 37 insertions(+), 2 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6725 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:32 +00:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
if (client->sasl.conn &&
|
2009-12-10 19:16:10 +00:00
|
|
|
client->sasl.username) {
|
2010-01-14 16:50:54 +00:00
|
|
|
qdict_put(qdict, "sasl_username",
|
|
|
|
qstring_from_str(client->sasl.username));
|
2009-12-10 19:16:10 +00:00
|
|
|
}
|
Include auth credentials in 'info vnc' ("Daniel P. Berrange")
This patch extends the 'info vnc' monitor output to include information
about the VNC client authentication credentials.
For clients authenticated using SASL, this will output the username.
For clients authenticated using x509 certificates, this will output
the x509 distinguished name.
Auth can be stacked, so both username & x509 dname may be shown.
Server:
address: 0.0.0.0:5902
auth: vencrypt+x509+sasl
Client:
address: 10.33.6.67:38621
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
Client:
address: 10.33.6.63:38620
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
vnc-tls.c | 17 +++++++++++++++++
vnc-tls.h | 3 +++
vnc.c | 19 +++++++++++++++++--
3 files changed, 37 insertions(+), 2 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6725 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:32 +00:00
|
|
|
#endif
|
2010-01-14 16:50:56 +00:00
|
|
|
}
|
2009-12-10 19:16:10 +00:00
|
|
|
|
2010-01-14 16:50:56 +00:00
|
|
|
static void vnc_client_cache_addr(VncState *client)
|
|
|
|
{
|
|
|
|
QDict *qdict;
|
|
|
|
|
|
|
|
qdict = qdict_new();
|
|
|
|
if (vnc_qdict_remote_addr(qdict, client->csock) < 0) {
|
|
|
|
QDECREF(qdict);
|
|
|
|
/* XXX: how to report the error? */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
client->info = QOBJECT(qdict);
|
2009-03-06 20:27:05 +00:00
|
|
|
}
|
|
|
|
|
QMP: Introduce VNC_CONNECTED event
It's emitted when a VNC client connects to QEMU, client's information
such as port and IP address are provided.
Note that this event is emitted right when the connection is
established. This means that it happens before authentication
procedure and session initialization.
Event example:
{ "event": "VNC_CONNECTED",
"timestamp": { "seconds": 1262976601, "microseconds": 975795 },
"data": {
"server": { "auth": "sasl", "family": "ipv4",
"service": "5901", "host": "0.0.0.0" },
"client": { "family": "ipv4", "service": "58425",
"host": "127.0.0.1" } } }
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2010-01-14 16:50:57 +00:00
|
|
|
static void vnc_qmp_event(VncState *vs, MonitorEvent event)
|
|
|
|
{
|
|
|
|
QDict *server;
|
|
|
|
QObject *data;
|
|
|
|
|
|
|
|
if (!vs->info) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
server = qdict_new();
|
|
|
|
if (vnc_server_info_put(server) < 0) {
|
|
|
|
QDECREF(server);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data = qobject_from_jsonf("{ 'client': %p, 'server': %p }",
|
|
|
|
vs->info, QOBJECT(server));
|
|
|
|
|
|
|
|
monitor_protocol_event(event, data);
|
|
|
|
|
|
|
|
qobject_incref(vs->info);
|
|
|
|
qobject_decref(data);
|
|
|
|
}
|
|
|
|
|
2009-12-10 19:16:10 +00:00
|
|
|
static void info_vnc_iter(QObject *obj, void *opaque)
|
2007-02-05 20:20:30 +00:00
|
|
|
{
|
2009-12-10 19:16:10 +00:00
|
|
|
QDict *client;
|
|
|
|
Monitor *mon = opaque;
|
|
|
|
|
|
|
|
client = qobject_to_qdict(obj);
|
|
|
|
monitor_printf(mon, "Client:\n");
|
|
|
|
monitor_printf(mon, " address: %s:%s\n",
|
|
|
|
qdict_get_str(client, "host"),
|
|
|
|
qdict_get_str(client, "service"));
|
|
|
|
|
|
|
|
#ifdef CONFIG_VNC_TLS
|
|
|
|
monitor_printf(mon, " x509_dname: %s\n",
|
|
|
|
qdict_haskey(client, "x509_dname") ?
|
|
|
|
qdict_get_str(client, "x509_dname") : "none");
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
monitor_printf(mon, " username: %s\n",
|
2010-01-14 16:50:54 +00:00
|
|
|
qdict_haskey(client, "sasl_username") ?
|
|
|
|
qdict_get_str(client, "sasl_username") : "none");
|
2009-12-10 19:16:10 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void do_info_vnc_print(Monitor *mon, const QObject *data)
|
|
|
|
{
|
|
|
|
QDict *server;
|
|
|
|
QList *clients;
|
|
|
|
|
|
|
|
server = qobject_to_qdict(data);
|
2010-01-14 16:50:52 +00:00
|
|
|
if (qdict_get_bool(server, "enabled") == 0) {
|
2009-03-06 20:27:05 +00:00
|
|
|
monitor_printf(mon, "Server: disabled\n");
|
2009-12-10 19:16:10 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-03-06 20:27:05 +00:00
|
|
|
|
2009-12-10 19:16:10 +00:00
|
|
|
monitor_printf(mon, "Server:\n");
|
|
|
|
monitor_printf(mon, " address: %s:%s\n",
|
|
|
|
qdict_get_str(server, "host"),
|
|
|
|
qdict_get_str(server, "service"));
|
2010-01-14 16:50:53 +00:00
|
|
|
monitor_printf(mon, " auth: %s\n", qdict_get_str(server, "auth"));
|
2009-12-10 19:16:10 +00:00
|
|
|
|
|
|
|
clients = qdict_get_qlist(server, "clients");
|
|
|
|
if (qlist_empty(clients)) {
|
|
|
|
monitor_printf(mon, "Client: none\n");
|
|
|
|
} else {
|
|
|
|
qlist_iter(clients, info_vnc_iter, mon);
|
|
|
|
}
|
|
|
|
}
|
2009-03-06 20:27:05 +00:00
|
|
|
|
2009-12-10 19:16:10 +00:00
|
|
|
/**
|
|
|
|
* do_info_vnc(): Show VNC server information
|
|
|
|
*
|
|
|
|
* Return a QDict with server information. Connected clients are returned
|
|
|
|
* as a QList of QDicts.
|
|
|
|
*
|
|
|
|
* The main QDict contains the following:
|
|
|
|
*
|
2010-01-14 16:50:52 +00:00
|
|
|
* - "enabled": true or false
|
2009-12-10 19:16:10 +00:00
|
|
|
* - "host": server's IP address
|
2010-01-14 16:50:55 +00:00
|
|
|
* - "family": address family ("ipv4" or "ipv6")
|
2009-12-10 19:16:10 +00:00
|
|
|
* - "service": server's port number
|
2010-01-14 16:50:53 +00:00
|
|
|
* - "auth": authentication method
|
2009-12-10 19:16:10 +00:00
|
|
|
* - "clients": a QList of all connected clients
|
|
|
|
*
|
|
|
|
* Clients are described by a QDict, with the following information:
|
|
|
|
*
|
|
|
|
* - "host": client's IP address
|
2010-01-14 16:50:55 +00:00
|
|
|
* - "family": address family ("ipv4" or "ipv6")
|
2009-12-10 19:16:10 +00:00
|
|
|
* - "service": client's port number
|
|
|
|
* - "x509_dname": TLS dname (optional)
|
2010-01-14 16:50:54 +00:00
|
|
|
* - "sasl_username": SASL username (optional)
|
2009-12-10 19:16:10 +00:00
|
|
|
*
|
|
|
|
* Example:
|
|
|
|
*
|
2010-01-14 16:50:52 +00:00
|
|
|
* { "enabled": true, "host": "0.0.0.0", "service": "50402", "auth": "vnc",
|
2010-01-14 16:50:55 +00:00
|
|
|
* "family": "ipv4",
|
|
|
|
* "clients": [{ "host": "127.0.0.1", "service": "50401", "family": "ipv4" }]}
|
2009-12-10 19:16:10 +00:00
|
|
|
*/
|
|
|
|
void do_info_vnc(Monitor *mon, QObject **ret_data)
|
|
|
|
{
|
|
|
|
if (vnc_display == NULL || vnc_display->display == NULL) {
|
2010-01-14 16:50:52 +00:00
|
|
|
*ret_data = qobject_from_jsonf("{ 'enabled': false }");
|
2009-12-10 19:16:10 +00:00
|
|
|
} else {
|
|
|
|
QList *clist;
|
2009-03-06 20:27:05 +00:00
|
|
|
|
2009-12-10 19:16:10 +00:00
|
|
|
clist = qlist_new();
|
2009-03-06 20:27:05 +00:00
|
|
|
if (vnc_display->clients) {
|
|
|
|
VncState *client = vnc_display->clients;
|
|
|
|
while (client) {
|
2010-01-14 16:50:56 +00:00
|
|
|
if (client->info) {
|
|
|
|
/* incref so that it's not freed by upper layers */
|
|
|
|
qobject_incref(client->info);
|
|
|
|
qlist_append_obj(clist, client->info);
|
|
|
|
}
|
2009-03-06 20:27:05 +00:00
|
|
|
client = client->next;
|
|
|
|
}
|
2009-12-10 19:16:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-14 16:50:52 +00:00
|
|
|
*ret_data = qobject_from_jsonf("{ 'enabled': true, 'clients': %p }",
|
2009-12-10 19:16:10 +00:00
|
|
|
QOBJECT(clist));
|
|
|
|
assert(*ret_data != NULL);
|
|
|
|
|
2010-01-14 16:50:53 +00:00
|
|
|
if (vnc_server_info_put(qobject_to_qdict(*ret_data)) < 0) {
|
2009-12-10 19:16:10 +00:00
|
|
|
qobject_decref(*ret_data);
|
|
|
|
*ret_data = NULL;
|
2009-03-06 20:27:05 +00:00
|
|
|
}
|
2007-02-05 20:20:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-02 15:58:29 +00:00
|
|
|
static inline uint32_t vnc_has_feature(VncState *vs, int feature) {
|
|
|
|
return (vs->features & (1 << feature));
|
|
|
|
}
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
/* TODO
|
|
|
|
1) Get the queue working for IO.
|
|
|
|
2) there is some weirdness when using the -S option (the screen is grey
|
|
|
|
and not totally invalidated
|
|
|
|
3) resolutions > 1024
|
|
|
|
*/
|
|
|
|
|
2009-08-03 09:56:01 +00:00
|
|
|
static int vnc_update_client(VncState *vs, int has_dirty);
|
2009-06-16 12:19:48 +00:00
|
|
|
static void vnc_disconnect_start(VncState *vs);
|
|
|
|
static void vnc_disconnect_finish(VncState *vs);
|
2009-08-03 09:54:05 +00:00
|
|
|
static void vnc_init_timer(VncDisplay *vd);
|
|
|
|
static void vnc_remove_timer(VncDisplay *vd);
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
static void vnc_colordepth(VncState *vs);
|
2009-08-03 09:54:32 +00:00
|
|
|
static void framebuffer_update_request(VncState *vs, int incremental,
|
|
|
|
int x_position, int y_position,
|
|
|
|
int w, int h);
|
|
|
|
static void vnc_refresh(void *opaque);
|
|
|
|
static int vnc_refresh_server_surface(VncDisplay *vd);
|
2008-09-15 16:03:41 +00:00
|
|
|
|
2006-06-13 16:35:24 +00:00
|
|
|
static inline void vnc_set_bit(uint32_t *d, int k)
|
|
|
|
{
|
|
|
|
d[k >> 5] |= 1 << (k & 0x1f);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void vnc_clear_bit(uint32_t *d, int k)
|
|
|
|
{
|
|
|
|
d[k >> 5] &= ~(1 << (k & 0x1f));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void vnc_set_bits(uint32_t *d, int n, int nb_words)
|
|
|
|
{
|
|
|
|
int j;
|
|
|
|
|
|
|
|
j = 0;
|
|
|
|
while (n >= 32) {
|
|
|
|
d[j++] = -1;
|
|
|
|
n -= 32;
|
|
|
|
}
|
2007-09-16 21:08:06 +00:00
|
|
|
if (n > 0)
|
2006-06-13 16:35:24 +00:00
|
|
|
d[j++] = (1 << n) - 1;
|
|
|
|
while (j < nb_words)
|
|
|
|
d[j++] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int vnc_get_bit(const uint32_t *d, int k)
|
|
|
|
{
|
|
|
|
return (d[k >> 5] >> (k & 0x1f)) & 1;
|
|
|
|
}
|
|
|
|
|
2007-09-16 21:08:06 +00:00
|
|
|
static inline int vnc_and_bits(const uint32_t *d1, const uint32_t *d2,
|
2006-06-13 16:35:24 +00:00
|
|
|
int nb_words)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for(i = 0; i < nb_words; i++) {
|
|
|
|
if ((d1[i] & d2[i]) != 0)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
static void vnc_dpy_update(DisplayState *ds, int x, int y, int w, int h)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
2009-08-03 09:54:32 +00:00
|
|
|
VncDisplay *vd = ds->opaque;
|
|
|
|
struct VncSurface *s = &vd->guest;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
h += y;
|
|
|
|
|
2007-12-11 22:31:32 +00:00
|
|
|
/* round x down to ensure the loop only spans one 16-pixel block per,
|
|
|
|
iteration. otherwise, if (x % 16) != 0, the last iteration may span
|
|
|
|
two 16-pixel blocks but we only mark the first as dirty
|
|
|
|
*/
|
|
|
|
w += (x % 16);
|
|
|
|
x -= (x % 16);
|
|
|
|
|
2009-03-20 15:59:14 +00:00
|
|
|
x = MIN(x, s->ds->width);
|
|
|
|
y = MIN(y, s->ds->height);
|
|
|
|
w = MIN(x + w, s->ds->width) - x;
|
|
|
|
h = MIN(h, s->ds->height);
|
2008-05-20 00:07:58 +00:00
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
for (; y < h; y++)
|
2009-03-06 20:27:40 +00:00
|
|
|
for (i = 0; i < w; i += 16)
|
2009-03-20 15:59:14 +00:00
|
|
|
vnc_set_bit(s->dirty[y], (x + i) / 16);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
|
2009-03-06 20:27:40 +00:00
|
|
|
int32_t encoding)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
vnc_write_u16(vs, x);
|
|
|
|
vnc_write_u16(vs, y);
|
|
|
|
vnc_write_u16(vs, w);
|
|
|
|
vnc_write_u16(vs, h);
|
|
|
|
|
|
|
|
vnc_write_s32(vs, encoding);
|
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
void buffer_reserve(Buffer *buffer, size_t len)
|
2009-02-02 15:58:47 +00:00
|
|
|
{
|
|
|
|
if ((buffer->capacity - buffer->offset) < len) {
|
2009-03-06 20:27:40 +00:00
|
|
|
buffer->capacity += (len + 1024);
|
|
|
|
buffer->buffer = qemu_realloc(buffer->buffer, buffer->capacity);
|
|
|
|
if (buffer->buffer == NULL) {
|
|
|
|
fprintf(stderr, "vnc: out of memory\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
2009-02-02 15:58:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
int buffer_empty(Buffer *buffer)
|
2009-02-02 15:58:47 +00:00
|
|
|
{
|
|
|
|
return buffer->offset == 0;
|
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
uint8_t *buffer_end(Buffer *buffer)
|
2009-02-02 15:58:47 +00:00
|
|
|
{
|
|
|
|
return buffer->buffer + buffer->offset;
|
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
void buffer_reset(Buffer *buffer)
|
2009-02-02 15:58:47 +00:00
|
|
|
{
|
2009-03-06 20:27:40 +00:00
|
|
|
buffer->offset = 0;
|
2009-02-02 15:58:47 +00:00
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
void buffer_append(Buffer *buffer, const void *data, size_t len)
|
2009-02-02 15:58:47 +00:00
|
|
|
{
|
|
|
|
memcpy(buffer->buffer + buffer->offset, data, len);
|
|
|
|
buffer->offset += len;
|
|
|
|
}
|
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
static void vnc_dpy_resize(DisplayState *ds)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2006-12-14 13:36:01 +00:00
|
|
|
int size_changed;
|
2009-08-03 09:54:32 +00:00
|
|
|
VncDisplay *vd = ds->opaque;
|
|
|
|
VncState *vs = vd->clients;
|
|
|
|
|
|
|
|
/* server surface */
|
|
|
|
if (!vd->server)
|
|
|
|
vd->server = qemu_mallocz(sizeof(*vd->server));
|
|
|
|
if (vd->server->data)
|
|
|
|
qemu_free(vd->server->data);
|
|
|
|
*(vd->server) = *(ds->surface);
|
|
|
|
vd->server->data = qemu_mallocz(vd->server->linesize *
|
|
|
|
vd->server->height);
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-20 15:59:14 +00:00
|
|
|
/* guest surface */
|
2009-08-03 09:54:32 +00:00
|
|
|
if (!vd->guest.ds)
|
|
|
|
vd->guest.ds = qemu_mallocz(sizeof(*vd->guest.ds));
|
|
|
|
if (ds_get_bytes_per_pixel(ds) != vd->guest.ds->pf.bytes_per_pixel)
|
2007-10-30 22:38:53 +00:00
|
|
|
console_color_init(ds);
|
2009-08-03 09:54:32 +00:00
|
|
|
size_changed = ds_get_width(ds) != vd->guest.ds->width ||
|
|
|
|
ds_get_height(ds) != vd->guest.ds->height;
|
|
|
|
*(vd->guest.ds) = *(ds->surface);
|
|
|
|
memset(vd->guest.dirty, 0xFF, sizeof(vd->guest.dirty));
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
while (vs != NULL) {
|
2009-08-03 09:54:32 +00:00
|
|
|
vnc_colordepth(vs);
|
|
|
|
if (size_changed) {
|
|
|
|
if (vs->csock != -1 && vnc_has_feature(vs, VNC_FEATURE_RESIZE)) {
|
|
|
|
vnc_write_u8(vs, 0); /* msg id */
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u16(vs, 1); /* number of rects */
|
|
|
|
vnc_framebuffer_update(vs, 0, 0, ds_get_width(ds), ds_get_height(ds),
|
|
|
|
VNC_ENCODING_DESKTOPRESIZE);
|
|
|
|
vnc_flush(vs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
memset(vs->dirty, 0xFF, sizeof(vs->dirty));
|
2009-02-16 14:59:30 +00:00
|
|
|
vs = vs->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-14 18:11:49 +00:00
|
|
|
/* fastest code */
|
|
|
|
static void vnc_write_pixels_copy(VncState *vs, void *pixels, int size)
|
|
|
|
{
|
|
|
|
vnc_write(vs, pixels, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* slowest but generic code. */
|
|
|
|
static void vnc_convert_pixel(VncState *vs, uint8_t *buf, uint32_t v)
|
|
|
|
{
|
2008-09-15 16:03:41 +00:00
|
|
|
uint8_t r, g, b;
|
2009-08-03 09:54:32 +00:00
|
|
|
VncDisplay *vd = vs->vd;
|
|
|
|
|
|
|
|
r = ((((v & vd->server->pf.rmask) >> vd->server->pf.rshift) << vs->clientds.pf.rbits) >>
|
|
|
|
vd->server->pf.rbits);
|
|
|
|
g = ((((v & vd->server->pf.gmask) >> vd->server->pf.gshift) << vs->clientds.pf.gbits) >>
|
|
|
|
vd->server->pf.gbits);
|
|
|
|
b = ((((v & vd->server->pf.bmask) >> vd->server->pf.bshift) << vs->clientds.pf.bbits) >>
|
|
|
|
vd->server->pf.bbits);
|
2009-01-15 22:17:38 +00:00
|
|
|
v = (r << vs->clientds.pf.rshift) |
|
|
|
|
(g << vs->clientds.pf.gshift) |
|
|
|
|
(b << vs->clientds.pf.bshift);
|
|
|
|
switch(vs->clientds.pf.bytes_per_pixel) {
|
2006-05-14 18:11:49 +00:00
|
|
|
case 1:
|
|
|
|
buf[0] = v;
|
|
|
|
break;
|
|
|
|
case 2:
|
2009-01-15 22:17:38 +00:00
|
|
|
if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {
|
2006-05-14 18:11:49 +00:00
|
|
|
buf[0] = v >> 8;
|
|
|
|
buf[1] = v;
|
|
|
|
} else {
|
|
|
|
buf[1] = v >> 8;
|
|
|
|
buf[0] = v;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case 4:
|
2009-01-15 22:17:38 +00:00
|
|
|
if (vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) {
|
2006-05-14 18:11:49 +00:00
|
|
|
buf[0] = v >> 24;
|
|
|
|
buf[1] = v >> 16;
|
|
|
|
buf[2] = v >> 8;
|
|
|
|
buf[3] = v;
|
|
|
|
} else {
|
|
|
|
buf[3] = v >> 24;
|
|
|
|
buf[2] = v >> 16;
|
|
|
|
buf[1] = v >> 8;
|
|
|
|
buf[0] = v;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_write_pixels_generic(VncState *vs, void *pixels1, int size)
|
|
|
|
{
|
|
|
|
uint8_t buf[4];
|
2009-08-03 09:54:32 +00:00
|
|
|
VncDisplay *vd = vs->vd;
|
2006-05-14 18:11:49 +00:00
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
if (vd->server->pf.bytes_per_pixel == 4) {
|
2008-09-15 16:03:41 +00:00
|
|
|
uint32_t *pixels = pixels1;
|
|
|
|
int n, i;
|
|
|
|
n = size >> 2;
|
|
|
|
for(i = 0; i < n; i++) {
|
|
|
|
vnc_convert_pixel(vs, buf, pixels[i]);
|
2009-01-15 22:17:38 +00:00
|
|
|
vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
|
2008-09-15 16:03:41 +00:00
|
|
|
}
|
2009-08-03 09:54:32 +00:00
|
|
|
} else if (vd->server->pf.bytes_per_pixel == 2) {
|
2008-09-15 16:03:41 +00:00
|
|
|
uint16_t *pixels = pixels1;
|
|
|
|
int n, i;
|
|
|
|
n = size >> 1;
|
|
|
|
for(i = 0; i < n; i++) {
|
|
|
|
vnc_convert_pixel(vs, buf, pixels[i]);
|
2009-01-15 22:17:38 +00:00
|
|
|
vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
|
2008-09-15 16:03:41 +00:00
|
|
|
}
|
2009-08-03 09:54:32 +00:00
|
|
|
} else if (vd->server->pf.bytes_per_pixel == 1) {
|
2008-09-15 16:03:41 +00:00
|
|
|
uint8_t *pixels = pixels1;
|
|
|
|
int n, i;
|
|
|
|
n = size;
|
|
|
|
for(i = 0; i < n; i++) {
|
|
|
|
vnc_convert_pixel(vs, buf, pixels[i]);
|
2009-01-15 22:17:38 +00:00
|
|
|
vnc_write(vs, buf, vs->clientds.pf.bytes_per_pixel);
|
2008-09-15 16:03:41 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "vnc_write_pixels_generic: VncState color depth not supported\n");
|
2006-05-14 18:11:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
static void send_framebuffer_update_raw(VncState *vs, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
int i;
|
2007-12-16 03:02:09 +00:00
|
|
|
uint8_t *row;
|
2009-08-03 09:54:32 +00:00
|
|
|
VncDisplay *vd = vs->vd;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
row = vd->server->data + y * ds_get_linesize(vs->ds) + x * ds_get_bytes_per_pixel(vs->ds);
|
2006-04-30 21:28:36 +00:00
|
|
|
for (i = 0; i < h; i++) {
|
2009-03-06 20:27:40 +00:00
|
|
|
vs->write_pixels(vs, row, w * ds_get_bytes_per_pixel(vs->ds));
|
|
|
|
row += ds_get_linesize(vs->ds);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hextile_enc_cord(uint8_t *ptr, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
ptr[0] = ((x & 0x0F) << 4) | (y & 0x0F);
|
|
|
|
ptr[1] = (((w - 1) & 0x0F) << 4) | ((h - 1) & 0x0F);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define BPP 8
|
|
|
|
#include "vnchextile.h"
|
|
|
|
#undef BPP
|
|
|
|
|
|
|
|
#define BPP 16
|
|
|
|
#include "vnchextile.h"
|
|
|
|
#undef BPP
|
|
|
|
|
|
|
|
#define BPP 32
|
|
|
|
#include "vnchextile.h"
|
|
|
|
#undef BPP
|
|
|
|
|
2008-09-15 16:03:41 +00:00
|
|
|
#define GENERIC
|
|
|
|
#define BPP 8
|
|
|
|
#include "vnchextile.h"
|
|
|
|
#undef BPP
|
|
|
|
#undef GENERIC
|
|
|
|
|
|
|
|
#define GENERIC
|
|
|
|
#define BPP 16
|
|
|
|
#include "vnchextile.h"
|
|
|
|
#undef BPP
|
|
|
|
#undef GENERIC
|
|
|
|
|
2006-05-14 18:11:49 +00:00
|
|
|
#define GENERIC
|
|
|
|
#define BPP 32
|
|
|
|
#include "vnchextile.h"
|
|
|
|
#undef BPP
|
|
|
|
#undef GENERIC
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
static void send_framebuffer_update_hextile(VncState *vs, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
int has_fg, has_bg;
|
2008-09-15 16:03:41 +00:00
|
|
|
uint8_t *last_fg, *last_bg;
|
2009-08-03 09:54:32 +00:00
|
|
|
VncDisplay *vd = vs->vd;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
last_fg = (uint8_t *) qemu_malloc(vd->server->pf.bytes_per_pixel);
|
|
|
|
last_bg = (uint8_t *) qemu_malloc(vd->server->pf.bytes_per_pixel);
|
2006-04-30 21:28:36 +00:00
|
|
|
has_fg = has_bg = 0;
|
|
|
|
for (j = y; j < (y + h); j += 16) {
|
2009-03-06 20:27:40 +00:00
|
|
|
for (i = x; i < (x + w); i += 16) {
|
2007-09-16 21:08:06 +00:00
|
|
|
vs->send_hextile_tile(vs, i, j,
|
2006-05-14 18:11:49 +00:00
|
|
|
MIN(16, x + w - i), MIN(16, y + h - j),
|
2008-09-15 16:03:41 +00:00
|
|
|
last_bg, last_fg, &has_bg, &has_fg);
|
2009-03-06 20:27:40 +00:00
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
2008-09-15 16:03:41 +00:00
|
|
|
free(last_fg);
|
|
|
|
free(last_bg);
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2009-10-01 18:53:12 +00:00
|
|
|
#define ZALLOC_ALIGNMENT 16
|
|
|
|
|
|
|
|
static void *zalloc(void *x, unsigned items, unsigned size)
|
|
|
|
{
|
|
|
|
void *p;
|
|
|
|
|
|
|
|
size *= items;
|
|
|
|
size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
|
|
|
|
|
|
|
|
p = qemu_mallocz(size);
|
|
|
|
|
|
|
|
return (p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void zfree(void *x, void *addr)
|
|
|
|
{
|
|
|
|
qemu_free(addr);
|
|
|
|
}
|
|
|
|
|
2009-02-02 15:58:54 +00:00
|
|
|
static void vnc_zlib_init(VncState *vs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i=0; i<(sizeof(vs->zlib_stream) / sizeof(z_stream)); i++)
|
|
|
|
vs->zlib_stream[i].opaque = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_zlib_start(VncState *vs)
|
|
|
|
{
|
|
|
|
buffer_reset(&vs->zlib);
|
|
|
|
|
|
|
|
// make the output buffer be the zlib buffer, so we can compress it later
|
|
|
|
vs->zlib_tmp = vs->output;
|
|
|
|
vs->output = vs->zlib;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vnc_zlib_stop(VncState *vs, int stream_id)
|
|
|
|
{
|
|
|
|
z_streamp zstream = &vs->zlib_stream[stream_id];
|
|
|
|
int previous_out;
|
|
|
|
|
|
|
|
// switch back to normal output/zlib buffers
|
|
|
|
vs->zlib = vs->output;
|
|
|
|
vs->output = vs->zlib_tmp;
|
|
|
|
|
|
|
|
// compress the zlib buffer
|
|
|
|
|
|
|
|
// initialize the stream
|
|
|
|
// XXX need one stream per session
|
|
|
|
if (zstream->opaque != vs) {
|
|
|
|
int err;
|
|
|
|
|
|
|
|
VNC_DEBUG("VNC: initializing zlib stream %d\n", stream_id);
|
|
|
|
VNC_DEBUG("VNC: opaque = %p | vs = %p\n", zstream->opaque, vs);
|
2009-10-01 18:53:12 +00:00
|
|
|
zstream->zalloc = zalloc;
|
|
|
|
zstream->zfree = zfree;
|
2009-02-02 15:58:54 +00:00
|
|
|
|
|
|
|
err = deflateInit2(zstream, vs->tight_compression, Z_DEFLATED, MAX_WBITS,
|
|
|
|
MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
|
|
|
|
|
|
|
|
if (err != Z_OK) {
|
|
|
|
fprintf(stderr, "VNC: error initializing zlib\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
zstream->opaque = vs;
|
|
|
|
}
|
|
|
|
|
|
|
|
// XXX what to do if tight_compression changed in between?
|
|
|
|
|
|
|
|
// reserve memory in output buffer
|
|
|
|
buffer_reserve(&vs->output, vs->zlib.offset + 64);
|
|
|
|
|
|
|
|
// set pointers
|
|
|
|
zstream->next_in = vs->zlib.buffer;
|
|
|
|
zstream->avail_in = vs->zlib.offset;
|
|
|
|
zstream->next_out = vs->output.buffer + vs->output.offset;
|
|
|
|
zstream->avail_out = vs->output.capacity - vs->output.offset;
|
|
|
|
zstream->data_type = Z_BINARY;
|
|
|
|
previous_out = zstream->total_out;
|
|
|
|
|
|
|
|
// start encoding
|
|
|
|
if (deflate(zstream, Z_SYNC_FLUSH) != Z_OK) {
|
|
|
|
fprintf(stderr, "VNC: error during zlib compression\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
vs->output.offset = vs->output.capacity - zstream->avail_out;
|
|
|
|
return zstream->total_out - previous_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void send_framebuffer_update_zlib(VncState *vs, int x, int y, int w, int h)
|
|
|
|
{
|
|
|
|
int old_offset, new_offset, bytes_written;
|
|
|
|
|
|
|
|
vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_ZLIB);
|
|
|
|
|
|
|
|
// remember where we put in the follow-up size
|
|
|
|
old_offset = vs->output.offset;
|
|
|
|
vnc_write_s32(vs, 0);
|
|
|
|
|
|
|
|
// compress the stream
|
|
|
|
vnc_zlib_start(vs);
|
|
|
|
send_framebuffer_update_raw(vs, x, y, w, h);
|
|
|
|
bytes_written = vnc_zlib_stop(vs, 0);
|
|
|
|
|
|
|
|
if (bytes_written == -1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// hack in the size
|
|
|
|
new_offset = vs->output.offset;
|
|
|
|
vs->output.offset = old_offset;
|
|
|
|
vnc_write_u32(vs, bytes_written);
|
|
|
|
vs->output.offset = new_offset;
|
|
|
|
}
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
static void send_framebuffer_update(VncState *vs, int x, int y, int w, int h)
|
|
|
|
{
|
2009-02-02 15:58:43 +00:00
|
|
|
switch(vs->vnc_encoding) {
|
2009-03-06 20:27:40 +00:00
|
|
|
case VNC_ENCODING_ZLIB:
|
|
|
|
send_framebuffer_update_zlib(vs, x, y, w, h);
|
|
|
|
break;
|
|
|
|
case VNC_ENCODING_HEXTILE:
|
|
|
|
vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_HEXTILE);
|
|
|
|
send_framebuffer_update_hextile(vs, x, y, w, h);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
vnc_framebuffer_update(vs, x, y, w, h, VNC_ENCODING_RAW);
|
|
|
|
send_framebuffer_update_raw(vs, x, y, w, h);
|
|
|
|
break;
|
2009-02-02 15:58:43 +00:00
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
static void vnc_copy(VncState *vs, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2009-07-27 15:10:48 +00:00
|
|
|
/* send bitblit op to the vnc client */
|
2006-04-30 21:28:36 +00:00
|
|
|
vnc_write_u8(vs, 0); /* msg id */
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u16(vs, 1); /* number of rects */
|
2009-02-02 15:58:29 +00:00
|
|
|
vnc_framebuffer_update(vs, dst_x, dst_y, w, h, VNC_ENCODING_COPYRECT);
|
2006-04-30 21:28:36 +00:00
|
|
|
vnc_write_u16(vs, src_x);
|
|
|
|
vnc_write_u16(vs, src_y);
|
|
|
|
vnc_flush(vs);
|
|
|
|
}
|
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
static void vnc_dpy_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h)
|
|
|
|
{
|
|
|
|
VncDisplay *vd = ds->opaque;
|
2009-06-16 12:19:48 +00:00
|
|
|
VncState *vs, *vn;
|
2009-08-03 09:54:32 +00:00
|
|
|
uint8_t *src_row;
|
|
|
|
uint8_t *dst_row;
|
|
|
|
int i,x,y,pitch,depth,inc,w_lim,s;
|
|
|
|
int cmp_bytes;
|
2009-06-16 12:19:48 +00:00
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
vnc_refresh_server_surface(vd);
|
2009-06-16 12:19:48 +00:00
|
|
|
for (vs = vd->clients; vs != NULL; vs = vn) {
|
|
|
|
vn = vs->next;
|
|
|
|
if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {
|
|
|
|
vs->force_update = 1;
|
2009-08-03 09:54:32 +00:00
|
|
|
vnc_update_client(vs, 1);
|
2009-06-16 12:19:48 +00:00
|
|
|
/* vs might be free()ed here */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
/* do bitblit op on the local surface too */
|
|
|
|
pitch = ds_get_linesize(vd->ds);
|
|
|
|
depth = ds_get_bytes_per_pixel(vd->ds);
|
|
|
|
src_row = vd->server->data + pitch * src_y + depth * src_x;
|
|
|
|
dst_row = vd->server->data + pitch * dst_y + depth * dst_x;
|
|
|
|
y = dst_y;
|
|
|
|
inc = 1;
|
|
|
|
if (dst_y > src_y) {
|
|
|
|
/* copy backwards */
|
|
|
|
src_row += pitch * (h-1);
|
|
|
|
dst_row += pitch * (h-1);
|
|
|
|
pitch = -pitch;
|
|
|
|
y = dst_y + h - 1;
|
|
|
|
inc = -1;
|
|
|
|
}
|
|
|
|
w_lim = w - (16 - (dst_x % 16));
|
|
|
|
if (w_lim < 0)
|
|
|
|
w_lim = w;
|
|
|
|
else
|
|
|
|
w_lim = w - (w_lim % 16);
|
|
|
|
for (i = 0; i < h; i++) {
|
|
|
|
for (x = 0; x <= w_lim;
|
|
|
|
x += s, src_row += cmp_bytes, dst_row += cmp_bytes) {
|
|
|
|
if (x == w_lim) {
|
|
|
|
if ((s = w - w_lim) == 0)
|
|
|
|
break;
|
|
|
|
} else if (!x) {
|
|
|
|
s = (16 - (dst_x % 16));
|
|
|
|
s = MIN(s, w_lim);
|
|
|
|
} else {
|
|
|
|
s = 16;
|
|
|
|
}
|
|
|
|
cmp_bytes = s * depth;
|
|
|
|
if (memcmp(src_row, dst_row, cmp_bytes) == 0)
|
|
|
|
continue;
|
|
|
|
memmove(dst_row, src_row, cmp_bytes);
|
|
|
|
vs = vd->clients;
|
|
|
|
while (vs != NULL) {
|
|
|
|
if (!vnc_has_feature(vs, VNC_FEATURE_COPYRECT))
|
|
|
|
vnc_set_bit(vs->dirty[y], ((x + dst_x) / 16));
|
|
|
|
vs = vs->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
src_row += pitch - w * depth;
|
|
|
|
dst_row += pitch - w * depth;
|
|
|
|
y += inc;
|
|
|
|
}
|
|
|
|
|
2009-06-16 12:19:48 +00:00
|
|
|
for (vs = vd->clients; vs != NULL; vs = vs->next) {
|
2009-02-16 14:59:30 +00:00
|
|
|
if (vnc_has_feature(vs, VNC_FEATURE_COPYRECT))
|
|
|
|
vnc_copy(vs, src_x, src_y, dst_x, dst_y, w, h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
static int find_and_clear_dirty_height(struct VncState *vs,
|
2009-03-20 15:59:14 +00:00
|
|
|
int y, int last_x, int x)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
int h;
|
2009-08-03 09:54:32 +00:00
|
|
|
VncDisplay *vd = vs->vd;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
for (h = 1; h < (vd->server->height - y); h++) {
|
2009-03-06 20:27:40 +00:00
|
|
|
int tmp_x;
|
2009-08-03 09:54:32 +00:00
|
|
|
if (!vnc_get_bit(vs->dirty[y + h], last_x))
|
2009-03-06 20:27:40 +00:00
|
|
|
break;
|
|
|
|
for (tmp_x = last_x; tmp_x < x; tmp_x++)
|
2009-08-03 09:54:32 +00:00
|
|
|
vnc_clear_bit(vs->dirty[y + h], tmp_x);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
2009-08-03 09:56:01 +00:00
|
|
|
static int vnc_update_client(VncState *vs, int has_dirty)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
if (vs->need_update && vs->csock != -1) {
|
2009-08-03 09:54:32 +00:00
|
|
|
VncDisplay *vd = vs->vd;
|
2009-03-06 20:27:40 +00:00
|
|
|
int y;
|
|
|
|
int n_rectangles;
|
|
|
|
int saved_offset;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-08-03 09:54:05 +00:00
|
|
|
if (vs->output.offset && !vs->audio_cap && !vs->force_update)
|
2009-03-20 15:59:24 +00:00
|
|
|
/* kernel send buffers are full -> drop frames to throttle */
|
2009-08-03 09:56:01 +00:00
|
|
|
return 0;
|
2008-01-13 23:51:53 +00:00
|
|
|
|
2009-08-03 09:54:05 +00:00
|
|
|
if (!has_dirty && !vs->audio_cap && !vs->force_update)
|
2009-08-03 09:56:01 +00:00
|
|
|
return 0;
|
2009-03-06 20:27:40 +00:00
|
|
|
|
2009-03-20 15:59:14 +00:00
|
|
|
/*
|
|
|
|
* Send screen updates to the vnc client using the server
|
|
|
|
* surface and server dirty map. guest surface updates
|
|
|
|
* happening in parallel don't disturb us, the next pass will
|
|
|
|
* send them to the client.
|
|
|
|
*/
|
2009-03-06 20:27:40 +00:00
|
|
|
n_rectangles = 0;
|
|
|
|
vnc_write_u8(vs, 0); /* msg id */
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
saved_offset = vs->output.offset;
|
|
|
|
vnc_write_u16(vs, 0);
|
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
for (y = 0; y < vd->server->height; y++) {
|
2009-03-06 20:27:40 +00:00
|
|
|
int x;
|
|
|
|
int last_x = -1;
|
2009-08-03 09:54:32 +00:00
|
|
|
for (x = 0; x < vd->server->width / 16; x++) {
|
|
|
|
if (vnc_get_bit(vs->dirty[y], x)) {
|
2009-03-06 20:27:40 +00:00
|
|
|
if (last_x == -1) {
|
|
|
|
last_x = x;
|
|
|
|
}
|
2009-08-03 09:54:32 +00:00
|
|
|
vnc_clear_bit(vs->dirty[y], x);
|
2009-03-06 20:27:40 +00:00
|
|
|
} else {
|
|
|
|
if (last_x != -1) {
|
2009-08-03 09:54:32 +00:00
|
|
|
int h = find_and_clear_dirty_height(vs, y, last_x, x);
|
2009-03-06 20:27:40 +00:00
|
|
|
send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
|
|
|
|
n_rectangles++;
|
|
|
|
}
|
|
|
|
last_x = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (last_x != -1) {
|
2009-08-03 09:54:32 +00:00
|
|
|
int h = find_and_clear_dirty_height(vs, y, last_x, x);
|
2009-03-06 20:27:40 +00:00
|
|
|
send_framebuffer_update(vs, last_x * 16, y, (x - last_x) * 16, h);
|
|
|
|
n_rectangles++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
vs->output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;
|
|
|
|
vs->output.buffer[saved_offset + 1] = n_rectangles & 0xFF;
|
|
|
|
vnc_flush(vs);
|
2009-03-20 15:59:24 +00:00
|
|
|
vs->force_update = 0;
|
2009-08-03 09:56:01 +00:00
|
|
|
return n_rectangles;
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2009-08-03 09:54:05 +00:00
|
|
|
if (vs->csock == -1)
|
2009-06-16 12:19:48 +00:00
|
|
|
vnc_disconnect_finish(vs);
|
2009-08-03 09:56:01 +00:00
|
|
|
|
|
|
|
return 0;
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2008-12-01 20:57:48 +00:00
|
|
|
/* audio */
|
|
|
|
static void audio_capture_notify(void *opaque, audcnotification_e cmd)
|
|
|
|
{
|
|
|
|
VncState *vs = opaque;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case AUD_CNOTIFY_DISABLE:
|
|
|
|
vnc_write_u8(vs, 255);
|
|
|
|
vnc_write_u8(vs, 1);
|
|
|
|
vnc_write_u16(vs, 0);
|
|
|
|
vnc_flush(vs);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AUD_CNOTIFY_ENABLE:
|
|
|
|
vnc_write_u8(vs, 255);
|
|
|
|
vnc_write_u8(vs, 1);
|
|
|
|
vnc_write_u16(vs, 1);
|
|
|
|
vnc_flush(vs);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void audio_capture_destroy(void *opaque)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void audio_capture(void *opaque, void *buf, int size)
|
|
|
|
{
|
|
|
|
VncState *vs = opaque;
|
|
|
|
|
|
|
|
vnc_write_u8(vs, 255);
|
|
|
|
vnc_write_u8(vs, 1);
|
|
|
|
vnc_write_u16(vs, 2);
|
|
|
|
vnc_write_u32(vs, size);
|
|
|
|
vnc_write(vs, buf, size);
|
|
|
|
vnc_flush(vs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void audio_add(VncState *vs)
|
|
|
|
{
|
2009-03-05 23:01:23 +00:00
|
|
|
Monitor *mon = cur_mon;
|
2008-12-01 20:57:48 +00:00
|
|
|
struct audio_capture_ops ops;
|
|
|
|
|
|
|
|
if (vs->audio_cap) {
|
2009-03-05 23:01:23 +00:00
|
|
|
monitor_printf(mon, "audio already running\n");
|
2008-12-01 20:57:48 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ops.notify = audio_capture_notify;
|
|
|
|
ops.destroy = audio_capture_destroy;
|
|
|
|
ops.capture = audio_capture;
|
|
|
|
|
2009-05-13 23:11:35 +00:00
|
|
|
vs->audio_cap = AUD_add_capture(&vs->as, &ops, vs);
|
2008-12-01 20:57:48 +00:00
|
|
|
if (!vs->audio_cap) {
|
2009-03-05 23:01:23 +00:00
|
|
|
monitor_printf(mon, "Failed to add audio capture\n");
|
2008-12-01 20:57:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void audio_del(VncState *vs)
|
|
|
|
{
|
|
|
|
if (vs->audio_cap) {
|
|
|
|
AUD_del_capture(vs->audio_cap, vs);
|
|
|
|
vs->audio_cap = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-16 12:19:48 +00:00
|
|
|
static void vnc_disconnect_start(VncState *vs)
|
|
|
|
{
|
|
|
|
if (vs->csock == -1)
|
|
|
|
return;
|
|
|
|
qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL);
|
|
|
|
closesocket(vs->csock);
|
|
|
|
vs->csock = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_disconnect_finish(VncState *vs)
|
|
|
|
{
|
QMP: Introduce VNC_DISCONNECTED event
It's emitted when a VNC client disconnects from QEMU, client's
information such as port and IP address are provided.
Event example:
{ "event": "VNC_DISCONNECTED",
"timestamp": { "seconds": 1262976601, "microseconds": 975795 },
"data": {
"server": { "auth": "sasl", "family": "ipv4",
"service": "5901", "host": "0.0.0.0" },
"client": { "family": "ipv4", "service": "58425",
"host": "127.0.0.1", "sasl_username": "foo" } } }
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2010-01-14 16:50:58 +00:00
|
|
|
vnc_qmp_event(vs, QEVENT_VNC_DISCONNECTED);
|
|
|
|
|
2009-09-19 19:00:09 +00:00
|
|
|
if (vs->input.buffer) {
|
|
|
|
qemu_free(vs->input.buffer);
|
|
|
|
vs->input.buffer = NULL;
|
|
|
|
}
|
|
|
|
if (vs->output.buffer) {
|
|
|
|
qemu_free(vs->output.buffer);
|
|
|
|
vs->output.buffer = NULL;
|
|
|
|
}
|
2010-01-14 16:50:56 +00:00
|
|
|
|
|
|
|
qobject_decref(vs->info);
|
|
|
|
|
2009-06-16 12:19:48 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
|
|
|
vnc_tls_client_cleanup(vs);
|
|
|
|
#endif /* CONFIG_VNC_TLS */
|
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
vnc_sasl_client_cleanup(vs);
|
|
|
|
#endif /* CONFIG_VNC_SASL */
|
|
|
|
audio_del(vs);
|
|
|
|
|
|
|
|
VncState *p, *parent = NULL;
|
|
|
|
for (p = vs->vd->clients; p != NULL; p = p->next) {
|
|
|
|
if (p == vs) {
|
|
|
|
if (parent)
|
|
|
|
parent->next = p->next;
|
|
|
|
else
|
|
|
|
vs->vd->clients = p->next;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
parent = p;
|
|
|
|
}
|
|
|
|
if (!vs->vd->clients)
|
|
|
|
dcl->idle = 1;
|
|
|
|
|
2009-08-03 09:54:05 +00:00
|
|
|
vnc_remove_timer(vs->vd);
|
2009-09-25 12:30:57 +00:00
|
|
|
qemu_free(vs);
|
2009-06-16 12:19:48 +00:00
|
|
|
}
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
|
|
|
|
int vnc_client_io_error(VncState *vs, int ret, int last_errno)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
if (ret == 0 || ret == -1) {
|
2008-04-24 23:40:55 +00:00
|
|
|
if (ret == -1) {
|
|
|
|
switch (last_errno) {
|
|
|
|
case EINTR:
|
|
|
|
case EAGAIN:
|
|
|
|
#ifdef _WIN32
|
|
|
|
case WSAEWOULDBLOCK:
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-06-16 12:19:48 +00:00
|
|
|
VNC_DEBUG("Closing down client sock: ret %d, errno %d\n",
|
|
|
|
ret, ret < 0 ? last_errno : 0);
|
|
|
|
vnc_disconnect_start(vs);
|
2009-03-20 15:59:14 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
return 0;
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
|
|
|
|
void vnc_client_error(VncState *vs)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2009-06-16 12:19:48 +00:00
|
|
|
VNC_DEBUG("Closing down client sock: protocol error\n");
|
|
|
|
vnc_disconnect_start(vs);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Called to write a chunk of data to the client socket. The data may
|
|
|
|
* be the raw data, or may have already been encoded by SASL.
|
|
|
|
* The data will be written either straight onto the socket, or
|
|
|
|
* written via the GNUTLS wrappers, if TLS/SSL encryption is enabled
|
|
|
|
*
|
|
|
|
* NB, it is theoretically possible to have 2 layers of encryption,
|
|
|
|
* both SASL, and this TLS layer. It is highly unlikely in practice
|
|
|
|
* though, since SASL encryption will typically be a no-op if TLS
|
|
|
|
* is active
|
|
|
|
*
|
|
|
|
* Returns the number of bytes written, which may be less than
|
|
|
|
* the requested 'datalen' if the socket would block. Returns
|
|
|
|
* -1 on error, and disconnects the client socket.
|
|
|
|
*/
|
|
|
|
long vnc_client_write_buf(VncState *vs, const uint8_t *data, size_t datalen)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2006-05-03 21:18:59 +00:00
|
|
|
long ret;
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2009-03-06 20:27:23 +00:00
|
|
|
if (vs->tls.session) {
|
2009-03-06 20:27:40 +00:00
|
|
|
ret = gnutls_write(vs->tls.session, data, datalen);
|
|
|
|
if (ret < 0) {
|
|
|
|
if (ret == GNUTLS_E_AGAIN)
|
|
|
|
errno = EAGAIN;
|
|
|
|
else
|
|
|
|
errno = EIO;
|
|
|
|
ret = -1;
|
|
|
|
}
|
2007-08-25 01:37:51 +00:00
|
|
|
} else
|
|
|
|
#endif /* CONFIG_VNC_TLS */
|
2009-06-13 11:05:27 +00:00
|
|
|
ret = send(vs->csock, (const void *)data, datalen, 0);
|
2009-03-20 15:59:18 +00:00
|
|
|
VNC_DEBUG("Wrote wire %p %zd -> %ld\n", data, datalen, ret);
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
return vnc_client_io_error(vs, ret, socket_error());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called to write buffered data to the client socket, when not
|
|
|
|
* using any SASL SSF encryption layers. Will write as much data
|
|
|
|
* as possible without blocking. If all buffered data is written,
|
|
|
|
* will switch the FD poll() handler back to read monitoring.
|
|
|
|
*
|
|
|
|
* Returns the number of bytes written, which may be less than
|
|
|
|
* the buffered output data if the socket would block. Returns
|
|
|
|
* -1 on error, and disconnects the client socket.
|
|
|
|
*/
|
|
|
|
static long vnc_client_write_plain(VncState *vs)
|
|
|
|
{
|
|
|
|
long ret;
|
|
|
|
|
|
|
|
#ifdef CONFIG_VNC_SASL
|
2009-03-20 15:59:18 +00:00
|
|
|
VNC_DEBUG("Write Plain: Pending output %p size %zd offset %zd. Wait SSF %d\n",
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
vs->output.buffer, vs->output.capacity, vs->output.offset,
|
|
|
|
vs->sasl.waitWriteSSF);
|
|
|
|
|
|
|
|
if (vs->sasl.conn &&
|
|
|
|
vs->sasl.runSSF &&
|
|
|
|
vs->sasl.waitWriteSSF) {
|
|
|
|
ret = vnc_client_write_buf(vs, vs->output.buffer, vs->sasl.waitWriteSSF);
|
|
|
|
if (ret)
|
|
|
|
vs->sasl.waitWriteSSF -= ret;
|
|
|
|
} else
|
|
|
|
#endif /* CONFIG_VNC_SASL */
|
|
|
|
ret = vnc_client_write_buf(vs, vs->output.buffer, vs->output.offset);
|
2006-04-30 21:28:36 +00:00
|
|
|
if (!ret)
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
return 0;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
memmove(vs->output.buffer, vs->output.buffer + ret, (vs->output.offset - ret));
|
|
|
|
vs->output.offset -= ret;
|
|
|
|
|
|
|
|
if (vs->output.offset == 0) {
|
2009-03-06 20:27:40 +00:00
|
|
|
qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First function called whenever there is data to be written to
|
|
|
|
* the client socket. Will delegate actual work according to whether
|
|
|
|
* SASL SSF layers are enabled (thus requiring encryption calls)
|
|
|
|
*/
|
|
|
|
void vnc_client_write(void *opaque)
|
|
|
|
{
|
|
|
|
long ret;
|
|
|
|
VncState *vs = opaque;
|
|
|
|
|
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
if (vs->sasl.conn &&
|
|
|
|
vs->sasl.runSSF &&
|
|
|
|
!vs->sasl.waitWriteSSF)
|
|
|
|
ret = vnc_client_write_sasl(vs);
|
|
|
|
else
|
|
|
|
#endif /* CONFIG_VNC_SASL */
|
|
|
|
ret = vnc_client_write_plain(vs);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void vnc_read_when(VncState *vs, VncReadEvent *func, size_t expecting)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
vs->read_handler = func;
|
|
|
|
vs->read_handler_expect = expecting;
|
|
|
|
}
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Called to read a chunk of data from the client socket. The data may
|
|
|
|
* be the raw data, or may need to be further decoded by SASL.
|
|
|
|
* The data will be read either straight from to the socket, or
|
|
|
|
* read via the GNUTLS wrappers, if TLS/SSL encryption is enabled
|
|
|
|
*
|
|
|
|
* NB, it is theoretically possible to have 2 layers of encryption,
|
|
|
|
* both SASL, and this TLS layer. It is highly unlikely in practice
|
|
|
|
* though, since SASL encryption will typically be a no-op if TLS
|
|
|
|
* is active
|
|
|
|
*
|
|
|
|
* Returns the number of bytes read, which may be less than
|
|
|
|
* the requested 'datalen' if the socket would block. Returns
|
|
|
|
* -1 on error, and disconnects the client socket.
|
|
|
|
*/
|
|
|
|
long vnc_client_read_buf(VncState *vs, uint8_t *data, size_t datalen)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2006-05-03 21:18:59 +00:00
|
|
|
long ret;
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2009-03-06 20:27:23 +00:00
|
|
|
if (vs->tls.session) {
|
2009-03-06 20:27:40 +00:00
|
|
|
ret = gnutls_read(vs->tls.session, data, datalen);
|
|
|
|
if (ret < 0) {
|
|
|
|
if (ret == GNUTLS_E_AGAIN)
|
|
|
|
errno = EAGAIN;
|
|
|
|
else
|
|
|
|
errno = EIO;
|
|
|
|
ret = -1;
|
|
|
|
}
|
2007-08-25 01:37:51 +00:00
|
|
|
} else
|
|
|
|
#endif /* CONFIG_VNC_TLS */
|
2009-06-13 08:44:31 +00:00
|
|
|
ret = recv(vs->csock, (void *)data, datalen, 0);
|
2009-03-20 15:59:18 +00:00
|
|
|
VNC_DEBUG("Read wire %p %zd -> %ld\n", data, datalen, ret);
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
return vnc_client_io_error(vs, ret, socket_error());
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Called to read data from the client socket to the input buffer,
|
|
|
|
* when not using any SASL SSF encryption layers. Will read as much
|
|
|
|
* data as possible without blocking.
|
|
|
|
*
|
|
|
|
* Returns the number of bytes read. Returns -1 on error, and
|
|
|
|
* disconnects the client socket.
|
|
|
|
*/
|
|
|
|
static long vnc_client_read_plain(VncState *vs)
|
|
|
|
{
|
|
|
|
int ret;
|
2009-03-20 15:59:18 +00:00
|
|
|
VNC_DEBUG("Read plain %p size %zd offset %zd\n",
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
vs->input.buffer, vs->input.capacity, vs->input.offset);
|
|
|
|
buffer_reserve(&vs->input, 4096);
|
|
|
|
ret = vnc_client_read_buf(vs, buffer_end(&vs->input), 4096);
|
|
|
|
if (!ret)
|
|
|
|
return 0;
|
2006-04-30 21:28:36 +00:00
|
|
|
vs->input.offset += ret;
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First function called whenever there is more data to be read from
|
|
|
|
* the client socket. Will delegate actual work according to whether
|
|
|
|
* SASL SSF layers are enabled (thus requiring decryption calls)
|
|
|
|
*/
|
|
|
|
void vnc_client_read(void *opaque)
|
|
|
|
{
|
|
|
|
VncState *vs = opaque;
|
|
|
|
long ret;
|
|
|
|
|
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
if (vs->sasl.conn && vs->sasl.runSSF)
|
|
|
|
ret = vnc_client_read_sasl(vs);
|
|
|
|
else
|
|
|
|
#endif /* CONFIG_VNC_SASL */
|
|
|
|
ret = vnc_client_read_plain(vs);
|
2009-06-16 12:19:48 +00:00
|
|
|
if (!ret) {
|
|
|
|
if (vs->csock == -1)
|
|
|
|
vnc_disconnect_finish(vs);
|
2009-03-06 20:27:40 +00:00
|
|
|
return;
|
2009-06-16 12:19:48 +00:00
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
while (vs->read_handler && vs->input.offset >= vs->read_handler_expect) {
|
2009-03-06 20:27:40 +00:00
|
|
|
size_t len = vs->read_handler_expect;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = vs->read_handler(vs, vs->input.buffer, len);
|
2009-06-16 12:19:48 +00:00
|
|
|
if (vs->csock == -1) {
|
|
|
|
vnc_disconnect_finish(vs);
|
2009-03-06 20:27:40 +00:00
|
|
|
return;
|
2009-06-16 12:19:48 +00:00
|
|
|
}
|
2009-03-06 20:27:40 +00:00
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
memmove(vs->input.buffer, vs->input.buffer + len, (vs->input.offset - len));
|
|
|
|
vs->input.offset -= len;
|
|
|
|
} else {
|
|
|
|
vs->read_handler_expect = ret;
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void vnc_write(VncState *vs, const void *data, size_t len)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
buffer_reserve(&vs->output, len);
|
|
|
|
|
2009-06-16 12:19:48 +00:00
|
|
|
if (vs->csock != -1 && buffer_empty(&vs->output)) {
|
2009-03-06 20:27:40 +00:00
|
|
|
qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
buffer_append(&vs->output, data, len);
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void vnc_write_s32(VncState *vs, int32_t value)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
vnc_write_u32(vs, *(uint32_t *)&value);
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void vnc_write_u32(VncState *vs, uint32_t value)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
uint8_t buf[4];
|
|
|
|
|
|
|
|
buf[0] = (value >> 24) & 0xFF;
|
|
|
|
buf[1] = (value >> 16) & 0xFF;
|
|
|
|
buf[2] = (value >> 8) & 0xFF;
|
|
|
|
buf[3] = value & 0xFF;
|
|
|
|
|
|
|
|
vnc_write(vs, buf, 4);
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void vnc_write_u16(VncState *vs, uint16_t value)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2006-08-24 20:36:44 +00:00
|
|
|
uint8_t buf[2];
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
buf[0] = (value >> 8) & 0xFF;
|
|
|
|
buf[1] = value & 0xFF;
|
|
|
|
|
|
|
|
vnc_write(vs, buf, 2);
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void vnc_write_u8(VncState *vs, uint8_t value)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
vnc_write(vs, (char *)&value, 1);
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void vnc_flush(VncState *vs)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2009-06-16 12:19:48 +00:00
|
|
|
if (vs->csock != -1 && vs->output.offset)
|
2009-03-06 20:27:40 +00:00
|
|
|
vnc_client_write(vs);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
uint8_t read_u8(uint8_t *data, size_t offset)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
return data[offset];
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
uint16_t read_u16(uint8_t *data, size_t offset)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
int32_t read_s32(uint8_t *data, size_t offset)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
return (int32_t)((data[offset] << 24) | (data[offset + 1] << 16) |
|
2009-03-06 20:27:40 +00:00
|
|
|
(data[offset + 2] << 8) | data[offset + 3]);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
uint32_t read_u32(uint8_t *data, size_t offset)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
return ((data[offset] << 24) | (data[offset + 1] << 16) |
|
2009-03-06 20:27:40 +00:00
|
|
|
(data[offset + 2] << 8) | data[offset + 3]);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2007-12-16 03:02:09 +00:00
|
|
|
static void client_cut_text(VncState *vs, size_t len, uint8_t *text)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-02-05 20:14:10 +00:00
|
|
|
static void check_pointer_type_change(VncState *vs, int absolute)
|
|
|
|
{
|
2009-02-02 15:58:29 +00:00
|
|
|
if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE) && vs->absolute != absolute) {
|
2009-03-06 20:27:40 +00:00
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u16(vs, 1);
|
|
|
|
vnc_framebuffer_update(vs, absolute, 0,
|
|
|
|
ds_get_width(vs->ds), ds_get_height(vs->ds),
|
2009-02-02 15:58:29 +00:00
|
|
|
VNC_ENCODING_POINTER_TYPE_CHANGE);
|
2009-03-06 20:27:40 +00:00
|
|
|
vnc_flush(vs);
|
2007-02-05 20:14:10 +00:00
|
|
|
}
|
|
|
|
vs->absolute = absolute;
|
|
|
|
}
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
static void pointer_event(VncState *vs, int button_mask, int x, int y)
|
|
|
|
{
|
|
|
|
int buttons = 0;
|
|
|
|
int dz = 0;
|
|
|
|
|
|
|
|
if (button_mask & 0x01)
|
2009-03-06 20:27:40 +00:00
|
|
|
buttons |= MOUSE_EVENT_LBUTTON;
|
2006-04-30 21:28:36 +00:00
|
|
|
if (button_mask & 0x02)
|
2009-03-06 20:27:40 +00:00
|
|
|
buttons |= MOUSE_EVENT_MBUTTON;
|
2006-04-30 21:28:36 +00:00
|
|
|
if (button_mask & 0x04)
|
2009-03-06 20:27:40 +00:00
|
|
|
buttons |= MOUSE_EVENT_RBUTTON;
|
2006-04-30 21:28:36 +00:00
|
|
|
if (button_mask & 0x08)
|
2009-03-06 20:27:40 +00:00
|
|
|
dz = -1;
|
2006-04-30 21:28:36 +00:00
|
|
|
if (button_mask & 0x10)
|
2009-03-06 20:27:40 +00:00
|
|
|
dz = 1;
|
2007-02-05 20:14:10 +00:00
|
|
|
|
|
|
|
if (vs->absolute) {
|
2009-03-06 20:27:40 +00:00
|
|
|
kbd_mouse_event(x * 0x7FFF / (ds_get_width(vs->ds) - 1),
|
|
|
|
y * 0x7FFF / (ds_get_height(vs->ds) - 1),
|
|
|
|
dz, buttons);
|
2009-02-02 15:58:29 +00:00
|
|
|
} else if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE)) {
|
2009-03-06 20:27:40 +00:00
|
|
|
x -= 0x7FFF;
|
|
|
|
y -= 0x7FFF;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
kbd_mouse_event(x, y, dz, buttons);
|
2007-02-05 20:14:10 +00:00
|
|
|
} else {
|
2009-03-06 20:27:40 +00:00
|
|
|
if (vs->last_x != -1)
|
|
|
|
kbd_mouse_event(x - vs->last_x,
|
|
|
|
y - vs->last_y,
|
|
|
|
dz, buttons);
|
|
|
|
vs->last_x = x;
|
|
|
|
vs->last_y = y;
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
2007-02-05 20:14:10 +00:00
|
|
|
|
|
|
|
check_pointer_type_change(vs, kbd_mouse_is_absolute());
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2006-08-24 20:36:44 +00:00
|
|
|
static void reset_keys(VncState *vs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for(i = 0; i < 256; i++) {
|
|
|
|
if (vs->modifiers_state[i]) {
|
|
|
|
if (i & 0x80)
|
|
|
|
kbd_put_keycode(0xe0);
|
|
|
|
kbd_put_keycode(i | 0x80);
|
|
|
|
vs->modifiers_state[i] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-30 22:38:53 +00:00
|
|
|
static void press_key(VncState *vs, int keysym)
|
|
|
|
{
|
2009-02-16 14:59:30 +00:00
|
|
|
kbd_put_keycode(keysym2scancode(vs->vd->kbd_layout, keysym) & 0x7f);
|
|
|
|
kbd_put_keycode(keysym2scancode(vs->vd->kbd_layout, keysym) | 0x80);
|
2007-10-30 22:38:53 +00:00
|
|
|
}
|
|
|
|
|
2008-08-23 23:27:37 +00:00
|
|
|
static void do_key_event(VncState *vs, int down, int keycode, int sym)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2006-08-24 20:36:44 +00:00
|
|
|
/* QEMU console switch */
|
|
|
|
switch(keycode) {
|
|
|
|
case 0x2a: /* Left Shift */
|
|
|
|
case 0x36: /* Right Shift */
|
|
|
|
case 0x1d: /* Left CTRL */
|
|
|
|
case 0x9d: /* Right CTRL */
|
|
|
|
case 0x38: /* Left ALT */
|
|
|
|
case 0xb8: /* Right ALT */
|
|
|
|
if (down)
|
|
|
|
vs->modifiers_state[keycode] = 1;
|
|
|
|
else
|
|
|
|
vs->modifiers_state[keycode] = 0;
|
|
|
|
break;
|
2007-09-16 21:08:06 +00:00
|
|
|
case 0x02 ... 0x0a: /* '1' to '9' keys */
|
2006-08-24 20:36:44 +00:00
|
|
|
if (down && vs->modifiers_state[0x1d] && vs->modifiers_state[0x38]) {
|
|
|
|
/* Reset the modifiers sent to the current console */
|
|
|
|
reset_keys(vs);
|
|
|
|
console_select(keycode - 0x02);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
2009-03-06 20:27:40 +00:00
|
|
|
case 0x3a: /* CapsLock */
|
|
|
|
case 0x45: /* NumLock */
|
2007-10-30 22:38:53 +00:00
|
|
|
if (!down)
|
|
|
|
vs->modifiers_state[keycode] ^= 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
if (keycode_is_keypad(vs->vd->kbd_layout, keycode)) {
|
2007-10-30 22:38:53 +00:00
|
|
|
/* If the numlock state needs to change then simulate an additional
|
|
|
|
keypress before sending this one. This will happen if the user
|
|
|
|
toggles numlock away from the VNC window.
|
|
|
|
*/
|
2009-02-16 14:59:30 +00:00
|
|
|
if (keysym_is_numlock(vs->vd->kbd_layout, sym & 0xFFFF)) {
|
2007-10-30 22:38:53 +00:00
|
|
|
if (!vs->modifiers_state[0x45]) {
|
|
|
|
vs->modifiers_state[0x45] = 1;
|
|
|
|
press_key(vs, 0xff7f);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (vs->modifiers_state[0x45]) {
|
|
|
|
vs->modifiers_state[0x45] = 0;
|
|
|
|
press_key(vs, 0xff7f);
|
|
|
|
}
|
|
|
|
}
|
2006-08-24 20:36:44 +00:00
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-11-02 11:47:06 +00:00
|
|
|
if ((sym >= 'A' && sym <= 'Z') || (sym >= 'a' && sym <= 'z')) {
|
|
|
|
/* If the capslock state needs to change then simulate an additional
|
|
|
|
keypress before sending this one. This will happen if the user
|
|
|
|
toggles capslock away from the VNC window.
|
|
|
|
*/
|
|
|
|
int uppercase = !!(sym >= 'A' && sym <= 'Z');
|
|
|
|
int shift = !!(vs->modifiers_state[0x2a] | vs->modifiers_state[0x36]);
|
|
|
|
int capslock = !!(vs->modifiers_state[0x3a]);
|
|
|
|
if (capslock) {
|
|
|
|
if (uppercase == shift) {
|
|
|
|
vs->modifiers_state[0x3a] = 0;
|
|
|
|
press_key(vs, 0xffe5);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (uppercase != shift) {
|
|
|
|
vs->modifiers_state[0x3a] = 1;
|
|
|
|
press_key(vs, 0xffe5);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-08-24 20:36:44 +00:00
|
|
|
if (is_graphic_console()) {
|
|
|
|
if (keycode & 0x80)
|
|
|
|
kbd_put_keycode(0xe0);
|
|
|
|
if (down)
|
|
|
|
kbd_put_keycode(keycode & 0x7f);
|
|
|
|
else
|
|
|
|
kbd_put_keycode(keycode | 0x80);
|
|
|
|
} else {
|
|
|
|
/* QEMU console emulation */
|
|
|
|
if (down) {
|
2009-06-11 09:32:14 +00:00
|
|
|
int numlock = vs->modifiers_state[0x45];
|
2006-08-24 20:36:44 +00:00
|
|
|
switch (keycode) {
|
|
|
|
case 0x2a: /* Left Shift */
|
|
|
|
case 0x36: /* Right Shift */
|
|
|
|
case 0x1d: /* Left CTRL */
|
|
|
|
case 0x9d: /* Right CTRL */
|
|
|
|
case 0x38: /* Left ALT */
|
|
|
|
case 0xb8: /* Right ALT */
|
|
|
|
break;
|
|
|
|
case 0xc8:
|
|
|
|
kbd_put_keysym(QEMU_KEY_UP);
|
|
|
|
break;
|
|
|
|
case 0xd0:
|
|
|
|
kbd_put_keysym(QEMU_KEY_DOWN);
|
|
|
|
break;
|
|
|
|
case 0xcb:
|
|
|
|
kbd_put_keysym(QEMU_KEY_LEFT);
|
|
|
|
break;
|
|
|
|
case 0xcd:
|
|
|
|
kbd_put_keysym(QEMU_KEY_RIGHT);
|
|
|
|
break;
|
|
|
|
case 0xd3:
|
|
|
|
kbd_put_keysym(QEMU_KEY_DELETE);
|
|
|
|
break;
|
|
|
|
case 0xc7:
|
|
|
|
kbd_put_keysym(QEMU_KEY_HOME);
|
|
|
|
break;
|
|
|
|
case 0xcf:
|
|
|
|
kbd_put_keysym(QEMU_KEY_END);
|
|
|
|
break;
|
|
|
|
case 0xc9:
|
|
|
|
kbd_put_keysym(QEMU_KEY_PAGEUP);
|
|
|
|
break;
|
|
|
|
case 0xd1:
|
|
|
|
kbd_put_keysym(QEMU_KEY_PAGEDOWN);
|
|
|
|
break;
|
2009-06-11 09:32:14 +00:00
|
|
|
|
|
|
|
case 0x47:
|
|
|
|
kbd_put_keysym(numlock ? '7' : QEMU_KEY_HOME);
|
|
|
|
break;
|
|
|
|
case 0x48:
|
|
|
|
kbd_put_keysym(numlock ? '8' : QEMU_KEY_UP);
|
|
|
|
break;
|
|
|
|
case 0x49:
|
|
|
|
kbd_put_keysym(numlock ? '9' : QEMU_KEY_PAGEUP);
|
|
|
|
break;
|
|
|
|
case 0x4b:
|
|
|
|
kbd_put_keysym(numlock ? '4' : QEMU_KEY_LEFT);
|
|
|
|
break;
|
|
|
|
case 0x4c:
|
|
|
|
kbd_put_keysym('5');
|
|
|
|
break;
|
|
|
|
case 0x4d:
|
|
|
|
kbd_put_keysym(numlock ? '6' : QEMU_KEY_RIGHT);
|
|
|
|
break;
|
|
|
|
case 0x4f:
|
|
|
|
kbd_put_keysym(numlock ? '1' : QEMU_KEY_END);
|
|
|
|
break;
|
|
|
|
case 0x50:
|
|
|
|
kbd_put_keysym(numlock ? '2' : QEMU_KEY_DOWN);
|
|
|
|
break;
|
|
|
|
case 0x51:
|
|
|
|
kbd_put_keysym(numlock ? '3' : QEMU_KEY_PAGEDOWN);
|
|
|
|
break;
|
|
|
|
case 0x52:
|
|
|
|
kbd_put_keysym('0');
|
|
|
|
break;
|
|
|
|
case 0x53:
|
|
|
|
kbd_put_keysym(numlock ? '.' : QEMU_KEY_DELETE);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xb5:
|
|
|
|
kbd_put_keysym('/');
|
|
|
|
break;
|
|
|
|
case 0x37:
|
|
|
|
kbd_put_keysym('*');
|
|
|
|
break;
|
|
|
|
case 0x4a:
|
|
|
|
kbd_put_keysym('-');
|
|
|
|
break;
|
|
|
|
case 0x4e:
|
|
|
|
kbd_put_keysym('+');
|
|
|
|
break;
|
|
|
|
case 0x9c:
|
|
|
|
kbd_put_keysym('\n');
|
|
|
|
break;
|
|
|
|
|
2006-08-24 20:36:44 +00:00
|
|
|
default:
|
|
|
|
kbd_put_keysym(sym);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2006-05-01 21:44:22 +00:00
|
|
|
static void key_event(VncState *vs, int down, uint32_t sym)
|
|
|
|
{
|
2008-08-23 23:27:37 +00:00
|
|
|
int keycode;
|
2009-12-11 10:25:07 +00:00
|
|
|
int lsym = sym;
|
2008-08-23 23:27:37 +00:00
|
|
|
|
2009-12-11 10:25:07 +00:00
|
|
|
if (lsym >= 'A' && lsym <= 'Z' && is_graphic_console()) {
|
|
|
|
lsym = lsym - 'A' + 'a';
|
|
|
|
}
|
2008-08-23 23:27:37 +00:00
|
|
|
|
2009-12-11 10:25:07 +00:00
|
|
|
keycode = keysym2scancode(vs->vd->kbd_layout, lsym & 0xFFFF);
|
2008-08-23 23:27:37 +00:00
|
|
|
do_key_event(vs, down, keycode, sym);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ext_key_event(VncState *vs, int down,
|
|
|
|
uint32_t sym, uint16_t keycode)
|
|
|
|
{
|
|
|
|
/* if the user specifies a keyboard layout, always use it */
|
|
|
|
if (keyboard_layout)
|
|
|
|
key_event(vs, down, sym);
|
|
|
|
else
|
|
|
|
do_key_event(vs, down, keycode, sym);
|
2006-05-01 21:44:22 +00:00
|
|
|
}
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
static void framebuffer_update_request(VncState *vs, int incremental,
|
2009-03-06 20:27:40 +00:00
|
|
|
int x_position, int y_position,
|
|
|
|
int w, int h)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2008-11-24 19:29:13 +00:00
|
|
|
if (x_position > ds_get_width(vs->ds))
|
|
|
|
x_position = ds_get_width(vs->ds);
|
|
|
|
if (y_position > ds_get_height(vs->ds))
|
|
|
|
y_position = ds_get_height(vs->ds);
|
|
|
|
if (x_position + w >= ds_get_width(vs->ds))
|
|
|
|
w = ds_get_width(vs->ds) - x_position;
|
|
|
|
if (y_position + h >= ds_get_height(vs->ds))
|
|
|
|
h = ds_get_height(vs->ds) - y_position;
|
2007-04-29 01:53:20 +00:00
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
int i;
|
|
|
|
vs->need_update = 1;
|
|
|
|
if (!incremental) {
|
2009-04-27 14:39:52 +00:00
|
|
|
vs->force_update = 1;
|
2009-03-06 20:27:40 +00:00
|
|
|
for (i = 0; i < h; i++) {
|
2009-08-03 09:54:32 +00:00
|
|
|
vnc_set_bits(vs->dirty[y_position + i],
|
2008-11-24 19:29:13 +00:00
|
|
|
(ds_get_width(vs->ds) / 16), VNC_DIRTY_WORDS);
|
2009-03-06 20:27:40 +00:00
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-08-23 23:27:37 +00:00
|
|
|
static void send_ext_key_event_ack(VncState *vs)
|
|
|
|
{
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u16(vs, 1);
|
2009-02-02 15:58:29 +00:00
|
|
|
vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds),
|
|
|
|
VNC_ENCODING_EXT_KEY_EVENT);
|
2008-08-23 23:27:37 +00:00
|
|
|
vnc_flush(vs);
|
|
|
|
}
|
|
|
|
|
2008-12-01 20:57:48 +00:00
|
|
|
static void send_ext_audio_ack(VncState *vs)
|
|
|
|
{
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u16(vs, 1);
|
2009-02-02 15:58:29 +00:00
|
|
|
vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds), ds_get_height(vs->ds),
|
|
|
|
VNC_ENCODING_AUDIO);
|
2008-12-01 20:57:48 +00:00
|
|
|
vnc_flush(vs);
|
|
|
|
}
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
static void set_encodings(VncState *vs, int32_t *encodings, size_t n_encodings)
|
|
|
|
{
|
|
|
|
int i;
|
2009-02-02 15:58:29 +00:00
|
|
|
unsigned int enc = 0;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-02-02 15:58:54 +00:00
|
|
|
vnc_zlib_init(vs);
|
2009-02-02 15:58:29 +00:00
|
|
|
vs->features = 0;
|
2009-02-02 15:58:43 +00:00
|
|
|
vs->vnc_encoding = 0;
|
|
|
|
vs->tight_compression = 9;
|
|
|
|
vs->tight_quality = 9;
|
2007-02-05 20:14:10 +00:00
|
|
|
vs->absolute = -1;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
for (i = n_encodings - 1; i >= 0; i--) {
|
2009-02-02 15:58:29 +00:00
|
|
|
enc = encodings[i];
|
|
|
|
switch (enc) {
|
|
|
|
case VNC_ENCODING_RAW:
|
2009-02-02 15:58:43 +00:00
|
|
|
vs->vnc_encoding = enc;
|
2009-02-02 15:58:29 +00:00
|
|
|
break;
|
|
|
|
case VNC_ENCODING_COPYRECT:
|
2009-02-16 14:59:30 +00:00
|
|
|
vs->features |= VNC_FEATURE_COPYRECT_MASK;
|
2009-02-02 15:58:29 +00:00
|
|
|
break;
|
|
|
|
case VNC_ENCODING_HEXTILE:
|
|
|
|
vs->features |= VNC_FEATURE_HEXTILE_MASK;
|
2009-02-02 15:58:43 +00:00
|
|
|
vs->vnc_encoding = enc;
|
2009-02-02 15:58:29 +00:00
|
|
|
break;
|
2009-02-02 15:58:54 +00:00
|
|
|
case VNC_ENCODING_ZLIB:
|
|
|
|
vs->features |= VNC_FEATURE_ZLIB_MASK;
|
|
|
|
vs->vnc_encoding = enc;
|
|
|
|
break;
|
2009-02-02 15:58:29 +00:00
|
|
|
case VNC_ENCODING_DESKTOPRESIZE:
|
|
|
|
vs->features |= VNC_FEATURE_RESIZE_MASK;
|
|
|
|
break;
|
|
|
|
case VNC_ENCODING_POINTER_TYPE_CHANGE:
|
|
|
|
vs->features |= VNC_FEATURE_POINTER_TYPE_CHANGE_MASK;
|
|
|
|
break;
|
|
|
|
case VNC_ENCODING_EXT_KEY_EVENT:
|
2008-08-23 23:27:37 +00:00
|
|
|
send_ext_key_event_ack(vs);
|
|
|
|
break;
|
2009-02-02 15:58:29 +00:00
|
|
|
case VNC_ENCODING_AUDIO:
|
2008-12-01 20:57:48 +00:00
|
|
|
send_ext_audio_ack(vs);
|
|
|
|
break;
|
2009-02-02 15:58:29 +00:00
|
|
|
case VNC_ENCODING_WMVi:
|
|
|
|
vs->features |= VNC_FEATURE_WMVI_MASK;
|
2008-09-15 16:05:16 +00:00
|
|
|
break;
|
2009-02-02 15:58:43 +00:00
|
|
|
case VNC_ENCODING_COMPRESSLEVEL0 ... VNC_ENCODING_COMPRESSLEVEL0 + 9:
|
|
|
|
vs->tight_compression = (enc & 0x0F);
|
|
|
|
break;
|
|
|
|
case VNC_ENCODING_QUALITYLEVEL0 ... VNC_ENCODING_QUALITYLEVEL0 + 9:
|
|
|
|
vs->tight_quality = (enc & 0x0F);
|
|
|
|
break;
|
2009-02-02 15:58:29 +00:00
|
|
|
default:
|
|
|
|
VNC_DEBUG("Unknown encoding: %d (0x%.8x): %d\n", i, enc, enc);
|
|
|
|
break;
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
2007-02-05 20:14:10 +00:00
|
|
|
|
|
|
|
check_pointer_type_change(vs, kbd_mouse_is_absolute());
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
|
2009-01-15 22:17:38 +00:00
|
|
|
static void set_pixel_conversion(VncState *vs)
|
|
|
|
{
|
|
|
|
if ((vs->clientds.flags & QEMU_BIG_ENDIAN_FLAG) ==
|
|
|
|
(vs->ds->surface->flags & QEMU_BIG_ENDIAN_FLAG) &&
|
|
|
|
!memcmp(&(vs->clientds.pf), &(vs->ds->surface->pf), sizeof(PixelFormat))) {
|
|
|
|
vs->write_pixels = vnc_write_pixels_copy;
|
|
|
|
switch (vs->ds->surface->pf.bits_per_pixel) {
|
|
|
|
case 8:
|
|
|
|
vs->send_hextile_tile = send_hextile_tile_8;
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
vs->send_hextile_tile = send_hextile_tile_16;
|
|
|
|
break;
|
|
|
|
case 32:
|
|
|
|
vs->send_hextile_tile = send_hextile_tile_32;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
vs->write_pixels = vnc_write_pixels_generic;
|
|
|
|
switch (vs->ds->surface->pf.bits_per_pixel) {
|
|
|
|
case 8:
|
|
|
|
vs->send_hextile_tile = send_hextile_tile_generic_8;
|
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
vs->send_hextile_tile = send_hextile_tile_generic_16;
|
|
|
|
break;
|
|
|
|
case 32:
|
|
|
|
vs->send_hextile_tile = send_hextile_tile_generic_32;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
static void set_pixel_format(VncState *vs,
|
2009-03-06 20:27:40 +00:00
|
|
|
int bits_per_pixel, int depth,
|
|
|
|
int big_endian_flag, int true_color_flag,
|
|
|
|
int red_max, int green_max, int blue_max,
|
|
|
|
int red_shift, int green_shift, int blue_shift)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2006-05-14 18:11:49 +00:00
|
|
|
if (!true_color_flag) {
|
2009-03-06 20:27:40 +00:00
|
|
|
vnc_client_error(vs);
|
2006-05-14 18:11:49 +00:00
|
|
|
return;
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
vs->clientds = *(vs->vd->guest.ds);
|
2009-01-15 22:17:38 +00:00
|
|
|
vs->clientds.pf.rmax = red_max;
|
2009-01-26 15:37:30 +00:00
|
|
|
count_bits(vs->clientds.pf.rbits, red_max);
|
2009-01-15 22:17:38 +00:00
|
|
|
vs->clientds.pf.rshift = red_shift;
|
|
|
|
vs->clientds.pf.rmask = red_max << red_shift;
|
|
|
|
vs->clientds.pf.gmax = green_max;
|
2009-01-26 15:37:30 +00:00
|
|
|
count_bits(vs->clientds.pf.gbits, green_max);
|
2009-01-15 22:17:38 +00:00
|
|
|
vs->clientds.pf.gshift = green_shift;
|
|
|
|
vs->clientds.pf.gmask = green_max << green_shift;
|
|
|
|
vs->clientds.pf.bmax = blue_max;
|
2009-01-26 15:37:30 +00:00
|
|
|
count_bits(vs->clientds.pf.bbits, blue_max);
|
2009-01-15 22:17:38 +00:00
|
|
|
vs->clientds.pf.bshift = blue_shift;
|
|
|
|
vs->clientds.pf.bmask = blue_max << blue_shift;
|
|
|
|
vs->clientds.pf.bits_per_pixel = bits_per_pixel;
|
|
|
|
vs->clientds.pf.bytes_per_pixel = bits_per_pixel / 8;
|
|
|
|
vs->clientds.pf.depth = bits_per_pixel == 32 ? 24 : bits_per_pixel;
|
|
|
|
vs->clientds.flags = big_endian_flag ? QEMU_BIG_ENDIAN_FLAG : 0x00;
|
|
|
|
|
|
|
|
set_pixel_conversion(vs);
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
vga_hw_invalidate();
|
|
|
|
vga_hw_update();
|
|
|
|
}
|
|
|
|
|
2008-09-15 16:05:16 +00:00
|
|
|
static void pixel_format_message (VncState *vs) {
|
|
|
|
char pad[3] = { 0, 0, 0 };
|
|
|
|
|
2009-01-15 22:17:38 +00:00
|
|
|
vnc_write_u8(vs, vs->ds->surface->pf.bits_per_pixel); /* bits-per-pixel */
|
|
|
|
vnc_write_u8(vs, vs->ds->surface->pf.depth); /* depth */
|
2008-09-15 16:05:16 +00:00
|
|
|
|
2009-07-27 14:13:06 +00:00
|
|
|
#ifdef HOST_WORDS_BIGENDIAN
|
2008-09-15 16:05:16 +00:00
|
|
|
vnc_write_u8(vs, 1); /* big-endian-flag */
|
|
|
|
#else
|
|
|
|
vnc_write_u8(vs, 0); /* big-endian-flag */
|
|
|
|
#endif
|
|
|
|
vnc_write_u8(vs, 1); /* true-color-flag */
|
2009-01-15 22:17:38 +00:00
|
|
|
vnc_write_u16(vs, vs->ds->surface->pf.rmax); /* red-max */
|
|
|
|
vnc_write_u16(vs, vs->ds->surface->pf.gmax); /* green-max */
|
|
|
|
vnc_write_u16(vs, vs->ds->surface->pf.bmax); /* blue-max */
|
|
|
|
vnc_write_u8(vs, vs->ds->surface->pf.rshift); /* red-shift */
|
|
|
|
vnc_write_u8(vs, vs->ds->surface->pf.gshift); /* green-shift */
|
|
|
|
vnc_write_u8(vs, vs->ds->surface->pf.bshift); /* blue-shift */
|
|
|
|
if (vs->ds->surface->pf.bits_per_pixel == 32)
|
2008-09-15 16:05:16 +00:00
|
|
|
vs->send_hextile_tile = send_hextile_tile_32;
|
2009-01-15 22:17:38 +00:00
|
|
|
else if (vs->ds->surface->pf.bits_per_pixel == 16)
|
2008-09-15 16:05:16 +00:00
|
|
|
vs->send_hextile_tile = send_hextile_tile_16;
|
2009-01-15 22:17:38 +00:00
|
|
|
else if (vs->ds->surface->pf.bits_per_pixel == 8)
|
2008-09-15 16:05:16 +00:00
|
|
|
vs->send_hextile_tile = send_hextile_tile_8;
|
2009-01-15 22:17:38 +00:00
|
|
|
vs->clientds = *(vs->ds->surface);
|
2009-04-07 19:57:09 +00:00
|
|
|
vs->clientds.flags &= ~QEMU_ALLOCATED_FLAG;
|
2008-09-15 16:05:16 +00:00
|
|
|
vs->write_pixels = vnc_write_pixels_copy;
|
|
|
|
|
|
|
|
vnc_write(vs, pad, 3); /* padding */
|
|
|
|
}
|
|
|
|
|
2009-01-15 22:14:11 +00:00
|
|
|
static void vnc_dpy_setdata(DisplayState *ds)
|
|
|
|
{
|
|
|
|
/* We don't have to do anything */
|
|
|
|
}
|
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
static void vnc_colordepth(VncState *vs)
|
2008-09-15 16:03:41 +00:00
|
|
|
{
|
2009-02-16 14:59:30 +00:00
|
|
|
if (vnc_has_feature(vs, VNC_FEATURE_WMVI)) {
|
2008-09-15 16:05:16 +00:00
|
|
|
/* Sending a WMVi message to notify the client*/
|
|
|
|
vnc_write_u8(vs, 0); /* msg id */
|
|
|
|
vnc_write_u8(vs, 0);
|
|
|
|
vnc_write_u16(vs, 1); /* number of rects */
|
2009-02-16 14:59:30 +00:00
|
|
|
vnc_framebuffer_update(vs, 0, 0, ds_get_width(vs->ds),
|
|
|
|
ds_get_height(vs->ds), VNC_ENCODING_WMVi);
|
2008-09-15 16:05:16 +00:00
|
|
|
pixel_format_message(vs);
|
|
|
|
vnc_flush(vs);
|
2008-09-15 16:03:41 +00:00
|
|
|
} else {
|
2009-01-15 22:17:38 +00:00
|
|
|
set_pixel_conversion(vs);
|
2008-09-15 16:03:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-16 03:02:09 +00:00
|
|
|
static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint16_t limit;
|
2009-08-03 09:56:01 +00:00
|
|
|
VncDisplay *vd = vs->vd;
|
|
|
|
|
|
|
|
if (data[0] > 3) {
|
|
|
|
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
|
|
|
|
if (!qemu_timer_expired(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval))
|
|
|
|
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
switch (data[0]) {
|
|
|
|
case 0:
|
2009-03-06 20:27:40 +00:00
|
|
|
if (len == 1)
|
|
|
|
return 20;
|
|
|
|
|
|
|
|
set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5),
|
|
|
|
read_u8(data, 6), read_u8(data, 7),
|
|
|
|
read_u16(data, 8), read_u16(data, 10),
|
|
|
|
read_u16(data, 12), read_u8(data, 14),
|
|
|
|
read_u8(data, 15), read_u8(data, 16));
|
|
|
|
break;
|
2006-04-30 21:28:36 +00:00
|
|
|
case 2:
|
2009-03-06 20:27:40 +00:00
|
|
|
if (len == 1)
|
|
|
|
return 4;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
if (len == 4) {
|
2008-12-22 21:06:23 +00:00
|
|
|
limit = read_u16(data, 2);
|
|
|
|
if (limit > 0)
|
|
|
|
return 4 + (limit * 4);
|
|
|
|
} else
|
|
|
|
limit = read_u16(data, 2);
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
for (i = 0; i < limit; i++) {
|
|
|
|
int32_t val = read_s32(data, 4 + (i * 4));
|
|
|
|
memcpy(data + 4 + (i * 4), &val, sizeof(val));
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
set_encodings(vs, (int32_t *)(data + 4), limit);
|
|
|
|
break;
|
2006-04-30 21:28:36 +00:00
|
|
|
case 3:
|
2009-03-06 20:27:40 +00:00
|
|
|
if (len == 1)
|
|
|
|
return 10;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
framebuffer_update_request(vs,
|
|
|
|
read_u8(data, 1), read_u16(data, 2), read_u16(data, 4),
|
|
|
|
read_u16(data, 6), read_u16(data, 8));
|
|
|
|
break;
|
2006-04-30 21:28:36 +00:00
|
|
|
case 4:
|
2009-03-06 20:27:40 +00:00
|
|
|
if (len == 1)
|
|
|
|
return 8;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
key_event(vs, read_u8(data, 1), read_u32(data, 4));
|
|
|
|
break;
|
2006-04-30 21:28:36 +00:00
|
|
|
case 5:
|
2009-03-06 20:27:40 +00:00
|
|
|
if (len == 1)
|
|
|
|
return 6;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
pointer_event(vs, read_u8(data, 1), read_u16(data, 2), read_u16(data, 4));
|
|
|
|
break;
|
2006-04-30 21:28:36 +00:00
|
|
|
case 6:
|
2009-03-06 20:27:40 +00:00
|
|
|
if (len == 1)
|
|
|
|
return 8;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
if (len == 8) {
|
2007-09-13 12:41:42 +00:00
|
|
|
uint32_t dlen = read_u32(data, 4);
|
|
|
|
if (dlen > 0)
|
|
|
|
return 8 + dlen;
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-03-06 20:27:40 +00:00
|
|
|
client_cut_text(vs, read_u32(data, 4), data + 8);
|
|
|
|
break;
|
2008-08-23 23:27:37 +00:00
|
|
|
case 255:
|
|
|
|
if (len == 1)
|
|
|
|
return 2;
|
|
|
|
|
|
|
|
switch (read_u8(data, 1)) {
|
|
|
|
case 0:
|
|
|
|
if (len == 2)
|
|
|
|
return 12;
|
|
|
|
|
|
|
|
ext_key_event(vs, read_u16(data, 2),
|
|
|
|
read_u32(data, 4), read_u32(data, 8));
|
|
|
|
break;
|
2008-12-01 20:57:48 +00:00
|
|
|
case 1:
|
|
|
|
if (len == 2)
|
|
|
|
return 4;
|
|
|
|
|
|
|
|
switch (read_u16 (data, 2)) {
|
|
|
|
case 0:
|
|
|
|
audio_add(vs);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
audio_del(vs);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
if (len == 4)
|
|
|
|
return 10;
|
|
|
|
switch (read_u8(data, 4)) {
|
|
|
|
case 0: vs->as.fmt = AUD_FMT_U8; break;
|
|
|
|
case 1: vs->as.fmt = AUD_FMT_S8; break;
|
|
|
|
case 2: vs->as.fmt = AUD_FMT_U16; break;
|
|
|
|
case 3: vs->as.fmt = AUD_FMT_S16; break;
|
|
|
|
case 4: vs->as.fmt = AUD_FMT_U32; break;
|
|
|
|
case 5: vs->as.fmt = AUD_FMT_S32; break;
|
|
|
|
default:
|
|
|
|
printf("Invalid audio format %d\n", read_u8(data, 4));
|
|
|
|
vnc_client_error(vs);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
vs->as.nchannels = read_u8(data, 5);
|
|
|
|
if (vs->as.nchannels != 1 && vs->as.nchannels != 2) {
|
|
|
|
printf("Invalid audio channel coount %d\n",
|
|
|
|
read_u8(data, 5));
|
|
|
|
vnc_client_error(vs);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
vs->as.freq = read_u32(data, 6);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf ("Invalid audio message %d\n", read_u8(data, 4));
|
|
|
|
vnc_client_error(vs);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2008-08-23 23:27:37 +00:00
|
|
|
default:
|
|
|
|
printf("Msg: %d\n", read_u16(data, 0));
|
|
|
|
vnc_client_error(vs);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2006-04-30 21:28:36 +00:00
|
|
|
default:
|
2009-03-06 20:27:40 +00:00
|
|
|
printf("Msg: %d\n", data[0]);
|
|
|
|
vnc_client_error(vs);
|
|
|
|
break;
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
2007-09-16 21:08:06 +00:00
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
vnc_read_when(vs, protocol_client_msg, 1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-16 03:02:09 +00:00
|
|
|
static int protocol_client_init(VncState *vs, uint8_t *data, size_t len)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2007-03-19 15:17:08 +00:00
|
|
|
char buf[1024];
|
|
|
|
int size;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2008-11-24 19:29:13 +00:00
|
|
|
vnc_write_u16(vs, ds_get_width(vs->ds));
|
|
|
|
vnc_write_u16(vs, ds_get_height(vs->ds));
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2008-09-15 16:05:16 +00:00
|
|
|
pixel_format_message(vs);
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2007-03-19 15:17:08 +00:00
|
|
|
if (qemu_name)
|
|
|
|
size = snprintf(buf, sizeof(buf), "QEMU (%s)", qemu_name);
|
|
|
|
else
|
|
|
|
size = snprintf(buf, sizeof(buf), "QEMU");
|
|
|
|
|
|
|
|
vnc_write_u32(vs, size);
|
|
|
|
vnc_write(vs, buf, size);
|
2006-04-30 21:28:36 +00:00
|
|
|
vnc_flush(vs);
|
|
|
|
|
2010-01-14 16:50:56 +00:00
|
|
|
vnc_client_cache_auth(vs);
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
vnc_read_when(vs, protocol_client_msg, 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void start_client_init(VncState *vs)
|
|
|
|
{
|
|
|
|
vnc_read_when(vs, protocol_client_init, 1);
|
|
|
|
}
|
|
|
|
|
2007-08-25 01:37:05 +00:00
|
|
|
static void make_challenge(VncState *vs)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
srand(time(NULL)+getpid()+getpid()*987654+rand());
|
|
|
|
|
|
|
|
for (i = 0 ; i < sizeof(vs->challenge) ; i++)
|
|
|
|
vs->challenge[i] = (int) (256.0*rand()/(RAND_MAX+1.0));
|
|
|
|
}
|
|
|
|
|
2007-12-16 03:02:09 +00:00
|
|
|
static int protocol_client_auth_vnc(VncState *vs, uint8_t *data, size_t len)
|
2007-08-25 01:37:05 +00:00
|
|
|
{
|
2007-12-16 03:02:09 +00:00
|
|
|
unsigned char response[VNC_AUTH_CHALLENGE_SIZE];
|
2007-08-25 01:37:05 +00:00
|
|
|
int i, j, pwlen;
|
2007-12-16 03:02:09 +00:00
|
|
|
unsigned char key[8];
|
2007-08-25 01:37:05 +00:00
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
if (!vs->vd->password || !vs->vd->password[0]) {
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("No password configured on server");
|
|
|
|
vnc_write_u32(vs, 1); /* Reject auth */
|
|
|
|
if (vs->minor >= 8) {
|
|
|
|
static const char err[] = "Authentication failed";
|
|
|
|
vnc_write_u32(vs, sizeof(err));
|
|
|
|
vnc_write(vs, err, sizeof(err));
|
|
|
|
}
|
|
|
|
vnc_flush(vs);
|
|
|
|
vnc_client_error(vs);
|
|
|
|
return 0;
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(response, vs->challenge, VNC_AUTH_CHALLENGE_SIZE);
|
|
|
|
|
|
|
|
/* Calculate the expected challenge response */
|
2009-02-16 14:59:30 +00:00
|
|
|
pwlen = strlen(vs->vd->password);
|
2007-08-25 01:37:05 +00:00
|
|
|
for (i=0; i<sizeof(key); i++)
|
2009-02-16 14:59:30 +00:00
|
|
|
key[i] = i<pwlen ? vs->vd->password[i] : 0;
|
2007-08-25 01:37:05 +00:00
|
|
|
deskey(key, EN0);
|
|
|
|
for (j = 0; j < VNC_AUTH_CHALLENGE_SIZE; j += 8)
|
|
|
|
des(response+j, response+j);
|
|
|
|
|
|
|
|
/* Compare expected vs actual challenge response */
|
|
|
|
if (memcmp(response, data, VNC_AUTH_CHALLENGE_SIZE) != 0) {
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Client challenge reponse did not match\n");
|
|
|
|
vnc_write_u32(vs, 1); /* Reject auth */
|
|
|
|
if (vs->minor >= 8) {
|
|
|
|
static const char err[] = "Authentication failed";
|
|
|
|
vnc_write_u32(vs, sizeof(err));
|
|
|
|
vnc_write(vs, err, sizeof(err));
|
|
|
|
}
|
|
|
|
vnc_flush(vs);
|
|
|
|
vnc_client_error(vs);
|
2007-08-25 01:37:05 +00:00
|
|
|
} else {
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Accepting VNC challenge response\n");
|
|
|
|
vnc_write_u32(vs, 0); /* Accept auth */
|
|
|
|
vnc_flush(vs);
|
2007-08-25 01:37:05 +00:00
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
start_client_init(vs);
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-06 20:27:23 +00:00
|
|
|
void start_auth_vnc(VncState *vs)
|
2007-08-25 01:37:05 +00:00
|
|
|
{
|
|
|
|
make_challenge(vs);
|
|
|
|
/* Send client a 'random' challenge */
|
|
|
|
vnc_write(vs, vs->challenge, sizeof(vs->challenge));
|
|
|
|
vnc_flush(vs);
|
|
|
|
|
|
|
|
vnc_read_when(vs, protocol_client_auth_vnc, sizeof(vs->challenge));
|
2007-08-25 01:39:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-12-16 03:02:09 +00:00
|
|
|
static int protocol_client_auth(VncState *vs, uint8_t *data, size_t len)
|
2007-08-25 01:37:05 +00:00
|
|
|
{
|
|
|
|
/* We only advertise 1 auth scheme at a time, so client
|
|
|
|
* must pick the one we sent. Verify this */
|
2009-02-16 14:59:30 +00:00
|
|
|
if (data[0] != vs->vd->auth) { /* Reject auth */
|
Include auth credentials in 'info vnc' ("Daniel P. Berrange")
This patch extends the 'info vnc' monitor output to include information
about the VNC client authentication credentials.
For clients authenticated using SASL, this will output the username.
For clients authenticated using x509 certificates, this will output
the x509 distinguished name.
Auth can be stacked, so both username & x509 dname may be shown.
Server:
address: 0.0.0.0:5902
auth: vencrypt+x509+sasl
Client:
address: 10.33.6.67:38621
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
Client:
address: 10.33.6.63:38620
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
vnc-tls.c | 17 +++++++++++++++++
vnc-tls.h | 3 +++
vnc.c | 19 +++++++++++++++++--
3 files changed, 37 insertions(+), 2 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6725 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:32 +00:00
|
|
|
VNC_DEBUG("Reject auth %d because it didn't match advertized\n", (int)data[0]);
|
2007-08-25 01:37:05 +00:00
|
|
|
vnc_write_u32(vs, 1);
|
|
|
|
if (vs->minor >= 8) {
|
|
|
|
static const char err[] = "Authentication failed";
|
|
|
|
vnc_write_u32(vs, sizeof(err));
|
|
|
|
vnc_write(vs, err, sizeof(err));
|
|
|
|
}
|
|
|
|
vnc_client_error(vs);
|
|
|
|
} else { /* Accept requested auth */
|
|
|
|
VNC_DEBUG("Client requested auth %d\n", (int)data[0]);
|
2009-02-16 14:59:30 +00:00
|
|
|
switch (vs->vd->auth) {
|
2007-08-25 01:37:05 +00:00
|
|
|
case VNC_AUTH_NONE:
|
|
|
|
VNC_DEBUG("Accept auth none\n");
|
2007-10-31 01:58:56 +00:00
|
|
|
if (vs->minor >= 8) {
|
|
|
|
vnc_write_u32(vs, 0); /* Accept auth completion */
|
|
|
|
vnc_flush(vs);
|
|
|
|
}
|
2009-03-06 20:27:23 +00:00
|
|
|
start_client_init(vs);
|
2007-08-25 01:37:05 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case VNC_AUTH_VNC:
|
|
|
|
VNC_DEBUG("Start VNC auth\n");
|
2009-03-06 20:27:23 +00:00
|
|
|
start_auth_vnc(vs);
|
|
|
|
break;
|
2007-08-25 01:37:05 +00:00
|
|
|
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2007-08-25 01:37:51 +00:00
|
|
|
case VNC_AUTH_VENCRYPT:
|
|
|
|
VNC_DEBUG("Accept VeNCrypt auth\n");;
|
2009-03-06 20:27:23 +00:00
|
|
|
start_auth_vencrypt(vs);
|
|
|
|
break;
|
2007-08-25 01:37:51 +00:00
|
|
|
#endif /* CONFIG_VNC_TLS */
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
case VNC_AUTH_SASL:
|
|
|
|
VNC_DEBUG("Accept SASL auth\n");
|
|
|
|
start_auth_sasl(vs);
|
|
|
|
break;
|
|
|
|
#endif /* CONFIG_VNC_SASL */
|
|
|
|
|
2007-08-25 01:37:05 +00:00
|
|
|
default: /* Should not be possible, but just in case */
|
Include auth credentials in 'info vnc' ("Daniel P. Berrange")
This patch extends the 'info vnc' monitor output to include information
about the VNC client authentication credentials.
For clients authenticated using SASL, this will output the username.
For clients authenticated using x509 certificates, this will output
the x509 distinguished name.
Auth can be stacked, so both username & x509 dname may be shown.
Server:
address: 0.0.0.0:5902
auth: vencrypt+x509+sasl
Client:
address: 10.33.6.67:38621
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
Client:
address: 10.33.6.63:38620
x509 dname: C=GB,O=ACME,L=London,ST=London,CN=localhost
username: admin
vnc-tls.c | 17 +++++++++++++++++
vnc-tls.h | 3 +++
vnc.c | 19 +++++++++++++++++--
3 files changed, 37 insertions(+), 2 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6725 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:32 +00:00
|
|
|
VNC_DEBUG("Reject auth %d server code bug\n", vs->vd->auth);
|
2007-08-25 01:37:05 +00:00
|
|
|
vnc_write_u8(vs, 1);
|
|
|
|
if (vs->minor >= 8) {
|
|
|
|
static const char err[] = "Authentication failed";
|
|
|
|
vnc_write_u32(vs, sizeof(err));
|
|
|
|
vnc_write(vs, err, sizeof(err));
|
|
|
|
}
|
|
|
|
vnc_client_error(vs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-16 03:02:09 +00:00
|
|
|
static int protocol_version(VncState *vs, uint8_t *version, size_t len)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
|
|
|
char local[13];
|
|
|
|
|
|
|
|
memcpy(local, version, 12);
|
|
|
|
local[12] = 0;
|
|
|
|
|
2007-08-25 01:37:05 +00:00
|
|
|
if (sscanf(local, "RFB %03d.%03d\n", &vs->major, &vs->minor) != 2) {
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Malformed protocol version %s\n", local);
|
|
|
|
vnc_client_error(vs);
|
|
|
|
return 0;
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
2007-08-25 01:37:05 +00:00
|
|
|
VNC_DEBUG("Client request protocol version %d.%d\n", vs->major, vs->minor);
|
|
|
|
if (vs->major != 3 ||
|
2009-03-06 20:27:40 +00:00
|
|
|
(vs->minor != 3 &&
|
|
|
|
vs->minor != 4 &&
|
|
|
|
vs->minor != 5 &&
|
|
|
|
vs->minor != 7 &&
|
|
|
|
vs->minor != 8)) {
|
|
|
|
VNC_DEBUG("Unsupported client version\n");
|
|
|
|
vnc_write_u32(vs, VNC_AUTH_INVALID);
|
|
|
|
vnc_flush(vs);
|
|
|
|
vnc_client_error(vs);
|
|
|
|
return 0;
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
2007-09-30 13:01:15 +00:00
|
|
|
/* Some broken clients report v3.4 or v3.5, which spec requires to be treated
|
2007-08-25 01:37:05 +00:00
|
|
|
* as equivalent to v3.3 by servers
|
|
|
|
*/
|
2007-09-30 13:01:15 +00:00
|
|
|
if (vs->minor == 4 || vs->minor == 5)
|
2009-03-06 20:27:40 +00:00
|
|
|
vs->minor = 3;
|
2007-08-25 01:37:05 +00:00
|
|
|
|
|
|
|
if (vs->minor == 3) {
|
2009-03-06 20:27:40 +00:00
|
|
|
if (vs->vd->auth == VNC_AUTH_NONE) {
|
2007-08-25 01:37:05 +00:00
|
|
|
VNC_DEBUG("Tell client auth none\n");
|
2009-02-16 14:59:30 +00:00
|
|
|
vnc_write_u32(vs, vs->vd->auth);
|
2007-08-25 01:37:05 +00:00
|
|
|
vnc_flush(vs);
|
2009-03-06 20:27:40 +00:00
|
|
|
start_client_init(vs);
|
2009-02-16 14:59:30 +00:00
|
|
|
} else if (vs->vd->auth == VNC_AUTH_VNC) {
|
2007-08-25 01:37:05 +00:00
|
|
|
VNC_DEBUG("Tell client VNC auth\n");
|
2009-02-16 14:59:30 +00:00
|
|
|
vnc_write_u32(vs, vs->vd->auth);
|
2007-08-25 01:37:05 +00:00
|
|
|
vnc_flush(vs);
|
|
|
|
start_auth_vnc(vs);
|
|
|
|
} else {
|
2009-02-16 14:59:30 +00:00
|
|
|
VNC_DEBUG("Unsupported auth %d for protocol 3.3\n", vs->vd->auth);
|
2007-08-25 01:37:05 +00:00
|
|
|
vnc_write_u32(vs, VNC_AUTH_INVALID);
|
|
|
|
vnc_flush(vs);
|
|
|
|
vnc_client_error(vs);
|
|
|
|
}
|
|
|
|
} else {
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Telling client we support auth %d\n", vs->vd->auth);
|
|
|
|
vnc_write_u8(vs, 1); /* num auth */
|
|
|
|
vnc_write_u8(vs, vs->vd->auth);
|
|
|
|
vnc_read_when(vs, protocol_client_auth, 1);
|
|
|
|
vnc_flush(vs);
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
static int vnc_refresh_server_surface(VncDisplay *vd)
|
|
|
|
{
|
|
|
|
int y;
|
|
|
|
uint8_t *guest_row;
|
|
|
|
uint8_t *server_row;
|
|
|
|
int cmp_bytes;
|
|
|
|
uint32_t width_mask[VNC_DIRTY_WORDS];
|
|
|
|
VncState *vs = NULL;
|
|
|
|
int has_dirty = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Walk through the guest dirty map.
|
|
|
|
* Check and copy modified bits from guest to server surface.
|
|
|
|
* Update server dirty map.
|
|
|
|
*/
|
|
|
|
vnc_set_bits(width_mask, (ds_get_width(vd->ds) / 16), VNC_DIRTY_WORDS);
|
|
|
|
cmp_bytes = 16 * ds_get_bytes_per_pixel(vd->ds);
|
|
|
|
guest_row = vd->guest.ds->data;
|
|
|
|
server_row = vd->server->data;
|
|
|
|
for (y = 0; y < vd->guest.ds->height; y++) {
|
|
|
|
if (vnc_and_bits(vd->guest.dirty[y], width_mask, VNC_DIRTY_WORDS)) {
|
|
|
|
int x;
|
|
|
|
uint8_t *guest_ptr;
|
|
|
|
uint8_t *server_ptr;
|
|
|
|
|
|
|
|
guest_ptr = guest_row;
|
|
|
|
server_ptr = server_row;
|
|
|
|
|
|
|
|
for (x = 0; x < vd->guest.ds->width;
|
|
|
|
x += 16, guest_ptr += cmp_bytes, server_ptr += cmp_bytes) {
|
|
|
|
if (!vnc_get_bit(vd->guest.dirty[y], (x / 16)))
|
|
|
|
continue;
|
|
|
|
vnc_clear_bit(vd->guest.dirty[y], (x / 16));
|
|
|
|
if (memcmp(server_ptr, guest_ptr, cmp_bytes) == 0)
|
|
|
|
continue;
|
|
|
|
memcpy(server_ptr, guest_ptr, cmp_bytes);
|
|
|
|
vs = vd->clients;
|
|
|
|
while (vs != NULL) {
|
|
|
|
vnc_set_bit(vs->dirty[y], (x / 16));
|
|
|
|
vs = vs->next;
|
|
|
|
}
|
|
|
|
has_dirty++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
guest_row += ds_get_linesize(vd->ds);
|
|
|
|
server_row += ds_get_linesize(vd->ds);
|
|
|
|
}
|
|
|
|
return has_dirty;
|
|
|
|
}
|
|
|
|
|
2009-08-03 09:54:05 +00:00
|
|
|
static void vnc_refresh(void *opaque)
|
|
|
|
{
|
|
|
|
VncDisplay *vd = opaque;
|
2009-08-03 09:54:32 +00:00
|
|
|
VncState *vs = NULL;
|
2009-08-03 09:56:01 +00:00
|
|
|
int has_dirty = 0, rects = 0;
|
2009-08-03 09:54:05 +00:00
|
|
|
|
|
|
|
vga_hw_update();
|
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
has_dirty = vnc_refresh_server_surface(vd);
|
|
|
|
|
|
|
|
vs = vd->clients;
|
2009-08-03 09:54:05 +00:00
|
|
|
while (vs != NULL) {
|
2009-08-03 09:56:01 +00:00
|
|
|
rects += vnc_update_client(vs, has_dirty);
|
2009-08-03 09:54:05 +00:00
|
|
|
vs = vs->next;
|
|
|
|
}
|
2010-01-11 17:30:50 +00:00
|
|
|
/* vd->timer could be NULL now if the last client disconnected,
|
|
|
|
* in this case don't update the timer */
|
|
|
|
if (vd->timer == NULL)
|
|
|
|
return;
|
2009-08-03 09:54:05 +00:00
|
|
|
|
2009-08-03 09:56:01 +00:00
|
|
|
if (has_dirty && rects) {
|
|
|
|
vd->timer_interval /= 2;
|
|
|
|
if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)
|
|
|
|
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
|
|
|
|
} else {
|
|
|
|
vd->timer_interval += VNC_REFRESH_INTERVAL_INC;
|
|
|
|
if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
|
|
|
|
vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
|
|
|
|
}
|
|
|
|
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
|
2009-08-03 09:54:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_init_timer(VncDisplay *vd)
|
|
|
|
{
|
2009-08-03 09:56:01 +00:00
|
|
|
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
|
2009-08-03 09:54:05 +00:00
|
|
|
if (vd->timer == NULL && vd->clients != NULL) {
|
|
|
|
vd->timer = qemu_new_timer(rt_clock, vnc_refresh, vd);
|
2009-08-03 09:54:32 +00:00
|
|
|
vnc_refresh(vd);
|
2009-08-03 09:54:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_remove_timer(VncDisplay *vd)
|
|
|
|
{
|
|
|
|
if (vd->timer != NULL && vd->clients == NULL) {
|
|
|
|
qemu_del_timer(vd->timer);
|
|
|
|
qemu_free_timer(vd->timer);
|
|
|
|
vd->timer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
static void vnc_connect(VncDisplay *vd, int csock)
|
2008-02-03 02:54:04 +00:00
|
|
|
{
|
2009-02-16 14:59:30 +00:00
|
|
|
VncState *vs = qemu_mallocz(sizeof(VncState));
|
|
|
|
vs->csock = csock;
|
|
|
|
|
|
|
|
VNC_DEBUG("New client on socket %d\n", csock);
|
2009-01-15 22:14:11 +00:00
|
|
|
dcl->idle = 0;
|
2008-02-03 02:54:04 +00:00
|
|
|
socket_set_nonblock(vs->csock);
|
|
|
|
qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
|
2009-02-16 14:59:30 +00:00
|
|
|
|
2010-01-14 16:50:56 +00:00
|
|
|
vnc_client_cache_addr(vs);
|
QMP: Introduce VNC_CONNECTED event
It's emitted when a VNC client connects to QEMU, client's information
such as port and IP address are provided.
Note that this event is emitted right when the connection is
established. This means that it happens before authentication
procedure and session initialization.
Event example:
{ "event": "VNC_CONNECTED",
"timestamp": { "seconds": 1262976601, "microseconds": 975795 },
"data": {
"server": { "auth": "sasl", "family": "ipv4",
"service": "5901", "host": "0.0.0.0" },
"client": { "family": "ipv4", "service": "58425",
"host": "127.0.0.1" } } }
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2010-01-14 16:50:57 +00:00
|
|
|
vnc_qmp_event(vs, QEVENT_VNC_CONNECTED);
|
2010-01-14 16:50:56 +00:00
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
vs->vd = vd;
|
|
|
|
vs->ds = vd->ds;
|
|
|
|
vs->last_x = -1;
|
|
|
|
vs->last_y = -1;
|
|
|
|
|
|
|
|
vs->as.freq = 44100;
|
|
|
|
vs->as.nchannels = 2;
|
|
|
|
vs->as.fmt = AUD_FMT_S16;
|
|
|
|
vs->as.endianness = 0;
|
|
|
|
|
2009-08-03 09:54:32 +00:00
|
|
|
vs->next = vd->clients;
|
|
|
|
vd->clients = vs;
|
|
|
|
|
|
|
|
vga_hw_update();
|
|
|
|
|
2008-02-03 02:54:04 +00:00
|
|
|
vnc_write(vs, "RFB 003.008\n", 12);
|
|
|
|
vnc_flush(vs);
|
|
|
|
vnc_read_when(vs, protocol_version, 12);
|
2008-12-01 20:57:52 +00:00
|
|
|
reset_keys(vs);
|
2009-02-16 14:59:30 +00:00
|
|
|
|
2009-08-03 09:54:05 +00:00
|
|
|
vnc_init_timer(vd);
|
2009-08-03 09:54:32 +00:00
|
|
|
|
2009-06-16 12:19:48 +00:00
|
|
|
/* vs might be free()ed here */
|
2008-02-03 02:54:04 +00:00
|
|
|
}
|
|
|
|
|
2006-04-30 21:28:36 +00:00
|
|
|
static void vnc_listen_read(void *opaque)
|
|
|
|
{
|
2009-02-16 14:59:30 +00:00
|
|
|
VncDisplay *vs = opaque;
|
2006-04-30 21:28:36 +00:00
|
|
|
struct sockaddr_in addr;
|
|
|
|
socklen_t addrlen = sizeof(addr);
|
|
|
|
|
2008-01-14 21:45:55 +00:00
|
|
|
/* Catch-up */
|
|
|
|
vga_hw_update();
|
|
|
|
|
2009-12-02 11:24:42 +00:00
|
|
|
int csock = qemu_accept(vs->lsock, (struct sockaddr *)&addr, &addrlen);
|
2009-02-16 14:59:30 +00:00
|
|
|
if (csock != -1) {
|
|
|
|
vnc_connect(vs, csock);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-25 01:35:38 +00:00
|
|
|
void vnc_display_init(DisplayState *ds)
|
2006-04-30 21:28:36 +00:00
|
|
|
{
|
2009-05-24 20:33:34 +00:00
|
|
|
VncDisplay *vs = qemu_mallocz(sizeof(*vs));
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-01-15 22:14:11 +00:00
|
|
|
dcl = qemu_mallocz(sizeof(DisplayChangeListener));
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
ds->opaque = vs;
|
2009-01-15 22:14:11 +00:00
|
|
|
dcl->idle = 1;
|
2009-02-16 14:59:30 +00:00
|
|
|
vnc_display = vs;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
vs->lsock = -1;
|
|
|
|
|
|
|
|
vs->ds = ds;
|
|
|
|
|
2008-08-23 23:27:37 +00:00
|
|
|
if (keyboard_layout)
|
2009-03-06 20:27:10 +00:00
|
|
|
vs->kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
|
2008-08-23 23:27:37 +00:00
|
|
|
else
|
2009-03-06 20:27:10 +00:00
|
|
|
vs->kbd_layout = init_keyboard_layout(name2keysym, "en-us");
|
2006-04-30 21:28:36 +00:00
|
|
|
|
|
|
|
if (!vs->kbd_layout)
|
2009-03-06 20:27:40 +00:00
|
|
|
exit(1);
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
dcl->dpy_copy = vnc_dpy_copy;
|
2009-01-15 22:14:11 +00:00
|
|
|
dcl->dpy_update = vnc_dpy_update;
|
|
|
|
dcl->dpy_resize = vnc_dpy_resize;
|
|
|
|
dcl->dpy_setdata = vnc_dpy_setdata;
|
|
|
|
register_displaychangelistener(ds, dcl);
|
2007-08-25 01:35:38 +00:00
|
|
|
}
|
|
|
|
|
2007-08-25 01:39:57 +00:00
|
|
|
|
2007-08-25 01:35:38 +00:00
|
|
|
void vnc_display_close(DisplayState *ds)
|
|
|
|
{
|
2009-02-16 14:59:30 +00:00
|
|
|
VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
|
2007-08-25 01:35:38 +00:00
|
|
|
|
2009-02-11 21:00:38 +00:00
|
|
|
if (!vs)
|
|
|
|
return;
|
2007-08-25 01:35:38 +00:00
|
|
|
if (vs->display) {
|
2009-03-06 20:27:40 +00:00
|
|
|
qemu_free(vs->display);
|
|
|
|
vs->display = NULL;
|
2007-08-25 01:35:38 +00:00
|
|
|
}
|
|
|
|
if (vs->lsock != -1) {
|
2009-03-06 20:27:40 +00:00
|
|
|
qemu_set_fd_handler2(vs->lsock, NULL, NULL, NULL, NULL);
|
|
|
|
close(vs->lsock);
|
|
|
|
vs->lsock = -1;
|
2007-08-25 01:35:38 +00:00
|
|
|
}
|
2007-08-25 01:37:05 +00:00
|
|
|
vs->auth = VNC_AUTH_INVALID;
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2007-08-25 01:37:51 +00:00
|
|
|
vs->subauth = VNC_AUTH_INVALID;
|
2009-03-06 20:27:23 +00:00
|
|
|
vs->tls.x509verify = 0;
|
2007-08-25 01:37:51 +00:00
|
|
|
#endif
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int vnc_display_password(DisplayState *ds, const char *password)
|
|
|
|
{
|
2009-02-16 14:59:30 +00:00
|
|
|
VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
|
2007-08-25 01:37:05 +00:00
|
|
|
|
2009-07-30 10:15:00 +00:00
|
|
|
if (!vs) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-08-25 01:37:05 +00:00
|
|
|
if (vs->password) {
|
2009-03-06 20:27:40 +00:00
|
|
|
qemu_free(vs->password);
|
|
|
|
vs->password = NULL;
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
|
|
|
if (password && password[0]) {
|
2009-03-06 20:27:40 +00:00
|
|
|
if (!(vs->password = qemu_strdup(password)))
|
|
|
|
return -1;
|
2009-07-30 10:15:01 +00:00
|
|
|
if (vs->auth == VNC_AUTH_NONE) {
|
|
|
|
vs->auth = VNC_AUTH_VNC;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
vs->auth = VNC_AUTH_NONE;
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2007-08-25 01:35:38 +00:00
|
|
|
}
|
|
|
|
|
2009-05-20 18:01:02 +00:00
|
|
|
char *vnc_display_local_addr(DisplayState *ds)
|
|
|
|
{
|
|
|
|
VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
|
|
|
|
|
|
|
|
return vnc_socket_local_addr("%s:%s", vs->lsock);
|
|
|
|
}
|
|
|
|
|
2007-08-25 01:37:05 +00:00
|
|
|
int vnc_display_open(DisplayState *ds, const char *display)
|
2007-08-25 01:35:38 +00:00
|
|
|
{
|
2009-02-16 14:59:30 +00:00
|
|
|
VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display;
|
2007-08-25 01:37:05 +00:00
|
|
|
const char *options;
|
|
|
|
int password = 0;
|
2008-02-03 02:54:04 +00:00
|
|
|
int reverse = 0;
|
2008-11-11 20:51:59 +00:00
|
|
|
int to_port = 0;
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2007-08-25 01:38:36 +00:00
|
|
|
int tls = 0, x509 = 0;
|
2007-08-25 01:37:51 +00:00
|
|
|
#endif
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
int sasl = 0;
|
|
|
|
int saslErr;
|
|
|
|
#endif
|
Support ACLs for controlling VNC access ("Daniel P. Berrange")
This patch introduces a generic internal API for access control lists
to be used by network servers in QEMU. It adds support for checking
these ACL in the VNC server, in two places. The first ACL is for the
SASL authentication mechanism, checking the SASL username. This ACL
is called 'vnc.username'. The second is for the TLS authentication
mechanism, when x509 client certificates are turned on, checking against
the Distinguished Name of the client. This ACL is called 'vnc.x509dname'
The internal API provides for an ACL with the following characteristics
- A unique name, eg vnc.username, and vnc.x509dname.
- A default policy, allow or deny
- An ordered series of match rules, with allow or deny policy
If none of the match rules apply, then the default policy is
used.
There is a monitor API to manipulate the ACLs, which I'll describe via
examples
(qemu) acl show vnc.username
policy: allow
(qemu) acl policy vnc.username denya
acl: policy set to 'deny'
(qemu) acl allow vnc.username fred
acl: added rule at position 1
(qemu) acl allow vnc.username bob
acl: added rule at position 2
(qemu) acl allow vnc.username joe 1
acl: added rule at position 1
(qemu) acl show vnc.username
policy: deny
0: allow fred
1: allow joe
2: allow bob
(qemu) acl show vnc.x509dname
policy: allow
(qemu) acl policy vnc.x509dname deny
acl: policy set to 'deny'
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=London,CN=*
acl: added rule at position 1
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=Boston,CN=bob
acl: added rule at position 2
(qemu) acl show vnc.x509dname
policy: deny
0: allow C=GB,O=ACME,L=London,CN=*
1: allow C=GB,O=ACME,L=Boston,CN=bob
By default the VNC server will not use any ACLs, allowing access to
the server if the user successfully authenticates. To enable use of
ACLs to restrict user access, the ',acl' flag should be given when
starting QEMU. The initial ACL activated will be a 'deny all' policy
and should be customized using monitor commands.
eg enable SASL auth and ACLs
qemu .... -vnc localhost:1,sasl,acl
The next patch will provide a way to load a pre-defined ACL when
starting up
Makefile | 6 +
b/acl.c | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
b/acl.h | 74 ++++++++++++++++++++++
configure | 18 +++++
monitor.c | 95 ++++++++++++++++++++++++++++
qemu-doc.texi | 49 ++++++++++++++
vnc-auth-sasl.c | 16 +++-
vnc-auth-sasl.h | 7 ++
vnc-tls.c | 19 +++++
vnc-tls.h | 3
vnc.c | 21 ++++++
vnc.h | 3
12 files changed, 491 insertions(+), 5 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6726 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:37 +00:00
|
|
|
int acl = 0;
|
2007-08-25 01:35:38 +00:00
|
|
|
|
2009-02-16 14:59:30 +00:00
|
|
|
if (!vnc_display)
|
2009-02-11 21:00:38 +00:00
|
|
|
return -1;
|
2007-08-25 01:35:38 +00:00
|
|
|
vnc_display_close(ds);
|
2007-08-25 01:37:05 +00:00
|
|
|
if (strcmp(display, "none") == 0)
|
2009-03-06 20:27:40 +00:00
|
|
|
return 0;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2007-08-25 01:37:05 +00:00
|
|
|
if (!(vs->display = strdup(display)))
|
2009-03-06 20:27:40 +00:00
|
|
|
return -1;
|
2007-08-25 01:37:05 +00:00
|
|
|
|
|
|
|
options = display;
|
|
|
|
while ((options = strchr(options, ','))) {
|
2009-03-06 20:27:40 +00:00
|
|
|
options++;
|
|
|
|
if (strncmp(options, "password", 8) == 0) {
|
|
|
|
password = 1; /* Require password auth */
|
|
|
|
} else if (strncmp(options, "reverse", 7) == 0) {
|
|
|
|
reverse = 1;
|
|
|
|
} else if (strncmp(options, "to=", 3) == 0) {
|
2008-11-11 20:51:59 +00:00
|
|
|
to_port = atoi(options+3) + 5900;
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
#ifdef CONFIG_VNC_SASL
|
2009-03-06 20:27:40 +00:00
|
|
|
} else if (strncmp(options, "sasl", 4) == 0) {
|
|
|
|
sasl = 1; /* Require SASL auth */
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
#endif
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2009-03-06 20:27:40 +00:00
|
|
|
} else if (strncmp(options, "tls", 3) == 0) {
|
|
|
|
tls = 1; /* Require TLS */
|
|
|
|
} else if (strncmp(options, "x509", 4) == 0) {
|
|
|
|
char *start, *end;
|
|
|
|
x509 = 1; /* Require x509 certificates */
|
|
|
|
if (strncmp(options, "x509verify", 10) == 0)
|
|
|
|
vs->tls.x509verify = 1; /* ...and verify client certs */
|
|
|
|
|
|
|
|
/* Now check for 'x509=/some/path' postfix
|
|
|
|
* and use that to setup x509 certificate/key paths */
|
|
|
|
start = strchr(options, '=');
|
|
|
|
end = strchr(options, ',');
|
|
|
|
if (start && (!end || (start < end))) {
|
|
|
|
int len = end ? end-(start+1) : strlen(start+1);
|
|
|
|
char *path = qemu_strndup(start + 1, len);
|
|
|
|
|
|
|
|
VNC_DEBUG("Trying certificate path '%s'\n", path);
|
|
|
|
if (vnc_tls_set_x509_creds_dir(vs, path) < 0) {
|
|
|
|
fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
|
|
|
|
qemu_free(path);
|
|
|
|
qemu_free(vs->display);
|
|
|
|
vs->display = NULL;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
qemu_free(path);
|
|
|
|
} else {
|
|
|
|
fprintf(stderr, "No certificate path provided\n");
|
|
|
|
qemu_free(vs->display);
|
|
|
|
vs->display = NULL;
|
|
|
|
return -1;
|
|
|
|
}
|
2007-08-25 01:37:51 +00:00
|
|
|
#endif
|
2009-03-06 20:27:40 +00:00
|
|
|
} else if (strncmp(options, "acl", 3) == 0) {
|
|
|
|
acl = 1;
|
|
|
|
}
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
|
|
|
|
Support ACLs for controlling VNC access ("Daniel P. Berrange")
This patch introduces a generic internal API for access control lists
to be used by network servers in QEMU. It adds support for checking
these ACL in the VNC server, in two places. The first ACL is for the
SASL authentication mechanism, checking the SASL username. This ACL
is called 'vnc.username'. The second is for the TLS authentication
mechanism, when x509 client certificates are turned on, checking against
the Distinguished Name of the client. This ACL is called 'vnc.x509dname'
The internal API provides for an ACL with the following characteristics
- A unique name, eg vnc.username, and vnc.x509dname.
- A default policy, allow or deny
- An ordered series of match rules, with allow or deny policy
If none of the match rules apply, then the default policy is
used.
There is a monitor API to manipulate the ACLs, which I'll describe via
examples
(qemu) acl show vnc.username
policy: allow
(qemu) acl policy vnc.username denya
acl: policy set to 'deny'
(qemu) acl allow vnc.username fred
acl: added rule at position 1
(qemu) acl allow vnc.username bob
acl: added rule at position 2
(qemu) acl allow vnc.username joe 1
acl: added rule at position 1
(qemu) acl show vnc.username
policy: deny
0: allow fred
1: allow joe
2: allow bob
(qemu) acl show vnc.x509dname
policy: allow
(qemu) acl policy vnc.x509dname deny
acl: policy set to 'deny'
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=London,CN=*
acl: added rule at position 1
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=Boston,CN=bob
acl: added rule at position 2
(qemu) acl show vnc.x509dname
policy: deny
0: allow C=GB,O=ACME,L=London,CN=*
1: allow C=GB,O=ACME,L=Boston,CN=bob
By default the VNC server will not use any ACLs, allowing access to
the server if the user successfully authenticates. To enable use of
ACLs to restrict user access, the ',acl' flag should be given when
starting QEMU. The initial ACL activated will be a 'deny all' policy
and should be customized using monitor commands.
eg enable SASL auth and ACLs
qemu .... -vnc localhost:1,sasl,acl
The next patch will provide a way to load a pre-defined ACL when
starting up
Makefile | 6 +
b/acl.c | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
b/acl.h | 74 ++++++++++++++++++++++
configure | 18 +++++
monitor.c | 95 ++++++++++++++++++++++++++++
qemu-doc.texi | 49 ++++++++++++++
vnc-auth-sasl.c | 16 +++-
vnc-auth-sasl.h | 7 ++
vnc-tls.c | 19 +++++
vnc-tls.h | 3
vnc.c | 21 ++++++
vnc.h | 3
12 files changed, 491 insertions(+), 5 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6726 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:37 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
|
|
|
if (acl && x509 && vs->tls.x509verify) {
|
2009-03-06 20:27:40 +00:00
|
|
|
if (!(vs->tls.acl = qemu_acl_init("vnc.x509dname"))) {
|
|
|
|
fprintf(stderr, "Failed to create x509 dname ACL\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
Support ACLs for controlling VNC access ("Daniel P. Berrange")
This patch introduces a generic internal API for access control lists
to be used by network servers in QEMU. It adds support for checking
these ACL in the VNC server, in two places. The first ACL is for the
SASL authentication mechanism, checking the SASL username. This ACL
is called 'vnc.username'. The second is for the TLS authentication
mechanism, when x509 client certificates are turned on, checking against
the Distinguished Name of the client. This ACL is called 'vnc.x509dname'
The internal API provides for an ACL with the following characteristics
- A unique name, eg vnc.username, and vnc.x509dname.
- A default policy, allow or deny
- An ordered series of match rules, with allow or deny policy
If none of the match rules apply, then the default policy is
used.
There is a monitor API to manipulate the ACLs, which I'll describe via
examples
(qemu) acl show vnc.username
policy: allow
(qemu) acl policy vnc.username denya
acl: policy set to 'deny'
(qemu) acl allow vnc.username fred
acl: added rule at position 1
(qemu) acl allow vnc.username bob
acl: added rule at position 2
(qemu) acl allow vnc.username joe 1
acl: added rule at position 1
(qemu) acl show vnc.username
policy: deny
0: allow fred
1: allow joe
2: allow bob
(qemu) acl show vnc.x509dname
policy: allow
(qemu) acl policy vnc.x509dname deny
acl: policy set to 'deny'
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=London,CN=*
acl: added rule at position 1
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=Boston,CN=bob
acl: added rule at position 2
(qemu) acl show vnc.x509dname
policy: deny
0: allow C=GB,O=ACME,L=London,CN=*
1: allow C=GB,O=ACME,L=Boston,CN=bob
By default the VNC server will not use any ACLs, allowing access to
the server if the user successfully authenticates. To enable use of
ACLs to restrict user access, the ',acl' flag should be given when
starting QEMU. The initial ACL activated will be a 'deny all' policy
and should be customized using monitor commands.
eg enable SASL auth and ACLs
qemu .... -vnc localhost:1,sasl,acl
The next patch will provide a way to load a pre-defined ACL when
starting up
Makefile | 6 +
b/acl.c | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
b/acl.h | 74 ++++++++++++++++++++++
configure | 18 +++++
monitor.c | 95 ++++++++++++++++++++++++++++
qemu-doc.texi | 49 ++++++++++++++
vnc-auth-sasl.c | 16 +++-
vnc-auth-sasl.h | 7 ++
vnc-tls.c | 19 +++++
vnc-tls.h | 3
vnc.c | 21 ++++++
vnc.h | 3
12 files changed, 491 insertions(+), 5 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6726 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:37 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
if (acl && sasl) {
|
2009-03-06 20:27:40 +00:00
|
|
|
if (!(vs->sasl.acl = qemu_acl_init("vnc.username"))) {
|
|
|
|
fprintf(stderr, "Failed to create username ACL\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
Support ACLs for controlling VNC access ("Daniel P. Berrange")
This patch introduces a generic internal API for access control lists
to be used by network servers in QEMU. It adds support for checking
these ACL in the VNC server, in two places. The first ACL is for the
SASL authentication mechanism, checking the SASL username. This ACL
is called 'vnc.username'. The second is for the TLS authentication
mechanism, when x509 client certificates are turned on, checking against
the Distinguished Name of the client. This ACL is called 'vnc.x509dname'
The internal API provides for an ACL with the following characteristics
- A unique name, eg vnc.username, and vnc.x509dname.
- A default policy, allow or deny
- An ordered series of match rules, with allow or deny policy
If none of the match rules apply, then the default policy is
used.
There is a monitor API to manipulate the ACLs, which I'll describe via
examples
(qemu) acl show vnc.username
policy: allow
(qemu) acl policy vnc.username denya
acl: policy set to 'deny'
(qemu) acl allow vnc.username fred
acl: added rule at position 1
(qemu) acl allow vnc.username bob
acl: added rule at position 2
(qemu) acl allow vnc.username joe 1
acl: added rule at position 1
(qemu) acl show vnc.username
policy: deny
0: allow fred
1: allow joe
2: allow bob
(qemu) acl show vnc.x509dname
policy: allow
(qemu) acl policy vnc.x509dname deny
acl: policy set to 'deny'
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=London,CN=*
acl: added rule at position 1
(qemu) acl allow vnc.x509dname C=GB,O=ACME,L=Boston,CN=bob
acl: added rule at position 2
(qemu) acl show vnc.x509dname
policy: deny
0: allow C=GB,O=ACME,L=London,CN=*
1: allow C=GB,O=ACME,L=Boston,CN=bob
By default the VNC server will not use any ACLs, allowing access to
the server if the user successfully authenticates. To enable use of
ACLs to restrict user access, the ',acl' flag should be given when
starting QEMU. The initial ACL activated will be a 'deny all' policy
and should be customized using monitor commands.
eg enable SASL auth and ACLs
qemu .... -vnc localhost:1,sasl,acl
The next patch will provide a way to load a pre-defined ACL when
starting up
Makefile | 6 +
b/acl.c | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
b/acl.h | 74 ++++++++++++++++++++++
configure | 18 +++++
monitor.c | 95 ++++++++++++++++++++++++++++
qemu-doc.texi | 49 ++++++++++++++
vnc-auth-sasl.c | 16 +++-
vnc-auth-sasl.h | 7 ++
vnc-tls.c | 19 +++++
vnc-tls.h | 3
vnc.c | 21 ++++++
vnc.h | 3
12 files changed, 491 insertions(+), 5 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6726 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:37 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
/*
|
|
|
|
* Combinations we support here:
|
|
|
|
*
|
|
|
|
* - no-auth (clear text, no auth)
|
|
|
|
* - password (clear text, weak auth)
|
|
|
|
* - sasl (encrypt, good auth *IF* using Kerberos via GSSAPI)
|
|
|
|
* - tls (encrypt, weak anonymous creds, no auth)
|
|
|
|
* - tls + password (encrypt, weak anonymous creds, weak auth)
|
|
|
|
* - tls + sasl (encrypt, weak anonymous creds, good auth)
|
|
|
|
* - tls + x509 (encrypt, good x509 creds, no auth)
|
|
|
|
* - tls + x509 + password (encrypt, good x509 creds, weak auth)
|
|
|
|
* - tls + x509 + sasl (encrypt, good x509 creds, good auth)
|
|
|
|
*
|
|
|
|
* NB1. TLS is a stackable auth scheme.
|
|
|
|
* NB2. the x509 schemes have option to validate a client cert dname
|
|
|
|
*/
|
2007-08-25 01:37:05 +00:00
|
|
|
if (password) {
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2009-03-06 20:27:40 +00:00
|
|
|
if (tls) {
|
|
|
|
vs->auth = VNC_AUTH_VENCRYPT;
|
|
|
|
if (x509) {
|
|
|
|
VNC_DEBUG("Initializing VNC server with x509 password auth\n");
|
|
|
|
vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
|
|
|
|
} else {
|
|
|
|
VNC_DEBUG("Initializing VNC server with TLS password auth\n");
|
|
|
|
vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
|
|
|
|
}
|
|
|
|
} else {
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
#endif /* CONFIG_VNC_TLS */
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Initializing VNC server with password auth\n");
|
|
|
|
vs->auth = VNC_AUTH_VNC;
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2009-03-06 20:27:40 +00:00
|
|
|
vs->subauth = VNC_AUTH_INVALID;
|
|
|
|
}
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
#endif /* CONFIG_VNC_TLS */
|
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
} else if (sasl) {
|
|
|
|
#ifdef CONFIG_VNC_TLS
|
|
|
|
if (tls) {
|
|
|
|
vs->auth = VNC_AUTH_VENCRYPT;
|
|
|
|
if (x509) {
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Initializing VNC server with x509 SASL auth\n");
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
vs->subauth = VNC_AUTH_VENCRYPT_X509SASL;
|
|
|
|
} else {
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Initializing VNC server with TLS SASL auth\n");
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
vs->subauth = VNC_AUTH_VENCRYPT_TLSSASL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
#endif /* CONFIG_VNC_TLS */
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Initializing VNC server with SASL auth\n");
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
vs->auth = VNC_AUTH_SASL;
|
|
|
|
#ifdef CONFIG_VNC_TLS
|
|
|
|
vs->subauth = VNC_AUTH_INVALID;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_VNC_TLS */
|
|
|
|
#endif /* CONFIG_VNC_SASL */
|
2007-08-25 01:37:05 +00:00
|
|
|
} else {
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2009-03-06 20:27:40 +00:00
|
|
|
if (tls) {
|
|
|
|
vs->auth = VNC_AUTH_VENCRYPT;
|
|
|
|
if (x509) {
|
|
|
|
VNC_DEBUG("Initializing VNC server with x509 no auth\n");
|
|
|
|
vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
|
|
|
|
} else {
|
|
|
|
VNC_DEBUG("Initializing VNC server with TLS no auth\n");
|
|
|
|
vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
|
|
|
|
}
|
|
|
|
} else {
|
2007-08-25 01:37:51 +00:00
|
|
|
#endif
|
2009-03-06 20:27:40 +00:00
|
|
|
VNC_DEBUG("Initializing VNC server with no auth\n");
|
|
|
|
vs->auth = VNC_AUTH_NONE;
|
2008-09-06 17:47:39 +00:00
|
|
|
#ifdef CONFIG_VNC_TLS
|
2009-03-06 20:27:40 +00:00
|
|
|
vs->subauth = VNC_AUTH_INVALID;
|
|
|
|
}
|
2007-08-25 01:37:51 +00:00
|
|
|
#endif
|
2007-08-25 01:37:05 +00:00
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
|
Add SASL authentication support ("Daniel P. Berrange")
This patch adds the new SASL authentication protocol to the VNC server.
It is enabled by setting the 'sasl' flag when launching VNC. SASL can
optionally provide encryption via its SSF layer, if a suitable mechanism
is configured (eg, GSSAPI/Kerberos, or Digest-MD5). If an SSF layer is
not available, then it should be combined with the x509 VNC authentication
protocol which provides encryption.
eg, if using GSSAPI
qemu -vnc localhost:1,sasl
eg if using TLS/x509 for encryption
qemu -vnc localhost:1,sasl,tls,x509
By default the Cyrus SASL library will look for its configuration in
the file /etc/sasl2/qemu.conf. For non-root users, this can be overridden
by setting the SASL_CONF_PATH environment variable, eg to make it look in
$HOME/.sasl2. NB unprivileged users may not have access to the full range
of SASL mechanisms, since some of them require some administrative privileges
to configure. The patch includes an example SASL configuration file which
illustrates config for GSSAPI and Digest-MD5, though it should be noted that
the latter is not really considered secure any more.
Most of the SASL authentication code is located in a separate source file,
vnc-auth-sasl.c. The main vnc.c file only contains minimal integration
glue, specifically parsing of command line flags / setup, and calls to
start the SASL auth process, to do encoding/decoding for data.
There are several possible stacks for reading & writing of data, depending
on the combo of VNC authentication methods in use
- Clear. read/write straight to socket
- TLS. read/write via GNUTLS helpers
- SASL. encode/decode via SASL SSF layer, then read/write to socket
- SASL+TLS. encode/decode via SASL SSF layer, then read/write via GNUTLS
Hence, the vnc_client_read & vnc_client_write methods have been refactored
a little.
vnc_client_read: main entry point for reading, calls either
- vnc_client_read_plain reading, with no intermediate decoding
- vnc_client_read_sasl reading, with SASL SSF decoding
These two methods, then call vnc_client_read_buf(). This decides
whether to write to the socket directly or write via GNUTLS.
The situation is the same for writing data. More extensive comments
have been added in the code / patch. The vnc_client_read_sasl and
vnc_client_write_sasl method implementations live in the separate
vnc-auth-sasl.c file.
The state required for the SASL auth mechanism is kept in a separate
VncStateSASL struct, defined in vnc-auth-sasl.h and included in the
main VncState.
The configure script probes for SASL and automatically enables it
if found, unless --disable-vnc-sasl was given to override it.
Makefile | 7
Makefile.target | 5
b/qemu.sasl | 34 ++
b/vnc-auth-sasl.c | 626 ++++++++++++++++++++++++++++++++++++++++++++++++++++
b/vnc-auth-sasl.h | 67 +++++
configure | 34 ++
qemu-doc.texi | 97 ++++++++
vnc-auth-vencrypt.c | 12
vnc.c | 249 ++++++++++++++++++--
vnc.h | 31 ++
10 files changed, 1129 insertions(+), 33 deletions(-)
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6724 c046a42c-6fe2-441c-8c8c-71466251a162
2009-03-06 20:27:28 +00:00
|
|
|
#ifdef CONFIG_VNC_SASL
|
|
|
|
if ((saslErr = sasl_server_init(NULL, "qemu")) != SASL_OK) {
|
|
|
|
fprintf(stderr, "Failed to initialize SASL auth %s",
|
|
|
|
sasl_errstring(saslErr, NULL, NULL));
|
|
|
|
free(vs->display);
|
|
|
|
vs->display = NULL;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-02-03 02:54:04 +00:00
|
|
|
if (reverse) {
|
2008-11-11 20:51:59 +00:00
|
|
|
/* connect to viewer */
|
|
|
|
if (strncmp(display, "unix:", 5) == 0)
|
|
|
|
vs->lsock = unix_connect(display+5);
|
|
|
|
else
|
|
|
|
vs->lsock = inet_connect(display, SOCK_STREAM);
|
|
|
|
if (-1 == vs->lsock) {
|
2008-02-03 02:54:04 +00:00
|
|
|
free(vs->display);
|
|
|
|
vs->display = NULL;
|
|
|
|
return -1;
|
|
|
|
} else {
|
2009-02-16 14:59:30 +00:00
|
|
|
int csock = vs->lsock;
|
2008-02-03 02:54:04 +00:00
|
|
|
vs->lsock = -1;
|
2009-02-16 14:59:30 +00:00
|
|
|
vnc_connect(vs, csock);
|
2008-02-03 02:54:04 +00:00
|
|
|
}
|
2008-11-11 20:51:59 +00:00
|
|
|
return 0;
|
2006-04-30 21:28:36 +00:00
|
|
|
|
2008-11-11 20:51:59 +00:00
|
|
|
} else {
|
|
|
|
/* listen for connects */
|
|
|
|
char *dpy;
|
|
|
|
dpy = qemu_malloc(256);
|
|
|
|
if (strncmp(display, "unix:", 5) == 0) {
|
2009-01-14 18:34:22 +00:00
|
|
|
pstrcpy(dpy, 256, "unix:");
|
2008-12-02 20:02:14 +00:00
|
|
|
vs->lsock = unix_listen(display+5, dpy+5, 256-5);
|
2008-11-11 20:51:59 +00:00
|
|
|
} else {
|
|
|
|
vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900);
|
|
|
|
}
|
|
|
|
if (-1 == vs->lsock) {
|
|
|
|
free(dpy);
|
2008-12-01 01:48:36 +00:00
|
|
|
return -1;
|
2008-11-11 20:51:59 +00:00
|
|
|
} else {
|
|
|
|
free(vs->display);
|
|
|
|
vs->display = dpy;
|
|
|
|
}
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|
2009-02-16 14:59:30 +00:00
|
|
|
return qemu_set_fd_handler2(vs->lsock, NULL, vnc_listen_read, NULL, vs);
|
2006-04-30 21:28:36 +00:00
|
|
|
}
|