Generic TLS support across VNC/chardev/migration
Subsystems (2)
cover Generic TLS support across VNC/chardev/migration
Earlier in the year I posted an RFC series providing impl of generic TLS support for VNC and chardevs.
https://lists.gnu.org/archive/html/qemu-devel/2015-04/msg02038.html
Since that time the initial QOM enhancements and crypto API consolidation patches from that RFC have been merged. I currently have a set of patches extracting the VNC server TLS support into a generic crypto API for TLS that is under active review, hopefully getting close to merge (v6):
https://lists.gnu.org/archive/html/qemu-devel/2015-09/msg00437.html
What I'm posting here is the 46 remaining patches I have that introduce TLS support across chardevs and migration code, and in the process standardize I/O channel handling across VNC, chardevs and migration. I'm doing this so people can see the use context of the TLS patches I have on review, as well as show the kind of changes I'm making to the migration, chardev & sockets code to facilitate conversations with other devs working on the same bits of code. As compared to the original RFC patches, this series is a more complete job - there is much more unit testing added and win32 compatibility verified, and many todos/hacks cleaned up.
I still need to figure out NBD integration, which is harder than I first thought, due to the need for me to understand the special needs of the block AIO framework, which doesn't seem to use the normal APIs for registering I/O callbacks with the main event loop.
I also realize that the ACL code needs to be QOM'ified to make it possible to create/delete ACLs more generically and share then across services.
I consider pretty much all of these patches as finished and ready for review, but this series is a bit large to be reviewed in one go, so I'm going to continue drip-feed it in reasonable sized chunks.
Some of these 46 patches are fairly generic and can be easily posted in isolation for quicker merge, so I will be focusing on identifying such patches and posting them individually to appropriate maintainers.
This series needs to be applied on top of the patch series here
https://lists.gnu.org/archive/html/qemu-devel/2015-09/msg00437.html
For convience I have pushed this entire branch to github
https://github.com/berrange/qemu/commits/qemu-io-channel-18
Daniel P. Berrange (46):
sockets: add helpers for creating SocketAddress from a socket
sockets: move qapi_copy_SocketAddress into qemu-sockets.c
sockets: allow port to be NULL when listening on IP address
osdep: add qemu_fork() wrapper for safely handling signals
coroutine: move into libqemuutil.a library
io: add abstract QIOChannel classes
io: add helper module for creating watches on FDs
io: pull Buffer code out of VNC module
io: add QIOTask class for async operations
io: add QIOChannelSocket class
io: add QIOChannelFile class
io: add QIOChannelTLS class
io: add QIOChannelWebsock class
io: add QIOChannelCommand class
ui: convert VNC startup code to use SocketAddress
ui: convert VNC server to use QIOChannelSocket
ui: convert VNC server to use QIOChannelTLS
ui: convert VNC server to use QIOChannelWebsock
char: remove fixed length filename allocation
char: convert from GIOChannel to QIOChannel
char: don't assume telnet initialization will not block
char: introduce support for TLS encrypted TCP chardev backend
nbd: convert to use the QAPI SocketAddress object
qemu-nbd: convert to use the QAPI SocketAddress object
sockets: remove use of QemuOpts from header file
sockets: remove use of QemuOpts from socket_listen
sockets: remove use of QemuOpts from socket_connect
sockets: remove use of QemuOpts from socket_dgram
migration: remove use of qemu_bufopen from vmstate tests
migration: remove memory buffer based QEMUFile backend
migration: move definition of struct QEMUFile back into qemu-file.c
migration: split migration hooks out of QEMUFileOps
migration: ensure qemu_fflush() always writes full data amount
migration: introduce qemu_fset_blocking function on QEMUFile
migration: force QEMUFile to blocking mode for outgoing migration
migration: introduce a new QEMUFile impl based on QIOChannel
migration: convert unix socket protocol to use QIOChannel
migration: convert tcp socket protocol to use QIOChannel
migration: convert fd socket protocol to use QIOChannel
migration: convert exec socket protocol to use QIOChannel
migration: convert RDMA to use QIOChannel interface
migration: convert savevm to use QIOChannel for writing to files
migration: delete QEMUFile sockets implementation
migration: delete QEMUFile stdio implementation
migration: support TLS encryption with TCP migration backend
migration: remove support for non-iovec based write handlers
MAINTAINERS | 7 +
Makefile | 2 +
Makefile.objs | 12 +-
Makefile.target | 2 +
block.c | 2 +-
block/nbd.c | 66 +--
block/qcow2.h | 2 +-
block/vdi.c | 2 +-
block/write-threshold.c | 2 +-
blockjob.c | 2 +-
configure | 11 +
coroutine-gthread.c | 2 +-
coroutine-sigaltstack.c | 2 +-
coroutine-ucontext.c | 2 +-
coroutine-win32.c | 2 +-
hw/9pfs/codir.c | 2 +-
hw/9pfs/cofile.c | 2 +-
hw/9pfs/cofs.c | 2 +-
hw/9pfs/coxattr.c | 2 +-
hw/9pfs/virtio-9p-coth.c | 2 +-
hw/9pfs/virtio-9p-coth.h | 2 +-
hw/9pfs/virtio-9p.h | 2 +-
include/block/block.h | 2 +-
include/block/block_int.h | 2 +-
include/io/buffer.h | 118 ++++
include/io/channel-command.h | 91 +++
include/io/channel-file.h | 93 +++
include/io/channel-socket.h | 297 ++++++++++
include/io/channel-tls.h | 142 +++++
include/io/channel-watch.h | 72 +++
include/io/channel-websock.h | 108 ++++
include/io/channel.h | 374 +++++++++++++
include/io/task.h | 256 +++++++++
include/migration/qemu-file.h | 48 +-
include/{block => qemu}/coroutine.h | 0
include/{block => qemu}/coroutine_int.h | 2 +-
include/qemu/osdep.h | 16 +
include/qemu/sockets.h | 44 +-
io/Makefile.objs | 9 +
io/buffer.c | 65 +++
io/channel-command.c | 370 ++++++++++++
io/channel-file.c | 209 +++++++
io/channel-socket.c | 718 ++++++++++++++++++++++++
io/channel-tls.c | 381 +++++++++++++
io/channel-watch.c | 200 +++++++
io/channel-websock.c | 965 ++++++++++++++++++++++++++++++++
io/channel.c | 229 ++++++++
io/task.c | 150 +++++
migration/Makefile.objs | 6 +-
migration/exec.c | 48 +-
migration/fd.c | 57 +-
migration/migration.c | 9 +-
migration/qemu-file-buf.c | 462 ---------------
migration/qemu-file-channel.c | 200 +++++++
migration/qemu-file-internal.h | 53 --
migration/qemu-file-stdio.c | 194 -------
migration/qemu-file-unix.c | 238 --------
migration/qemu-file.c | 113 ++--
migration/rdma.c | 252 ++++++---
migration/savevm.c | 16 +-
migration/tcp.c | 372 ++++++++++--
migration/unix.c | 103 ++--
nbd.c | 2 +-
qapi-schema.json | 2 +
qemu-char.c | 938 +++++++++++++++----------------
qemu-coroutine-io.c | 2 +-
qemu-coroutine-lock.c | 4 +-
qemu-coroutine-sleep.c | 2 +-
qemu-coroutine.c | 4 +-
qemu-nbd.c | 102 ++--
qemu-options.hx | 16 +-
scripts/create_config | 9 +
tests/.gitignore | 7 +
tests/Makefile | 22 +-
tests/io-channel-helpers.c | 247 ++++++++
tests/io-channel-helpers.h | 33 ++
tests/test-coroutine.c | 4 +-
tests/test-io-channel-command.c | 121 ++++
tests/test-io-channel-file.c | 89 +++
tests/test-io-channel-socket.c | 349 ++++++++++++
tests/test-io-channel-tls.c | 335 +++++++++++
tests/test-io-task.c | 276 +++++++++
tests/test-vmstate.c | 57 +-
thread-pool.c | 2 +-
ui/vnc-auth-sasl.c | 87 ++-
ui/vnc-auth-vencrypt.c | 93 ++-
ui/vnc-enc-tight.c | 38 +-
ui/vnc-enc-zlib.c | 6 +-
ui/vnc-enc-zrle.c | 18 +-
ui/vnc-jobs.c | 25 +-
ui/vnc-ws.c | 400 +++----------
ui/vnc-ws.h | 71 +--
ui/vnc.c | 799 ++++++++++++--------------
ui/vnc.h | 77 +--
util/oslib-posix.c | 71 +++
util/oslib-win32.c | 9 +
util/qemu-sockets.c | 427 ++++++++------
97 files changed, 8875 insertions(+), 3085 deletions(-)
create mode 100644 include/io/buffer.h
create mode 100644 include/io/channel-command.h
create mode 100644 include/io/channel-file.h
create mode 100644 include/io/channel-socket.h
create mode 100644 include/io/channel-tls.h
create mode 100644 include/io/channel-watch.h
create mode 100644 include/io/channel-websock.h
create mode 100644 include/io/channel.h
create mode 100644 include/io/task.h
rename include/{block => qemu}/coroutine.h (100%)
rename include/{block => qemu}/coroutine_int.h (98%)
create mode 100644 io/Makefile.objs
create mode 100644 io/buffer.c
create mode 100644 io/channel-command.c
create mode 100644 io/channel-file.c
create mode 100644 io/channel-socket.c
create mode 100644 io/channel-tls.c
create mode 100644 io/channel-watch.c
create mode 100644 io/channel-websock.c
create mode 100644 io/channel.c
create mode 100644 io/task.c
delete mode 100644 migration/qemu-file-buf.c
create mode 100644 migration/qemu-file-channel.c
delete mode 100644 migration/qemu-file-internal.h
delete mode 100644 migration/qemu-file-stdio.c
delete mode 100644 migration/qemu-file-unix.c
create mode 100644 tests/io-channel-helpers.c
create mode 100644 tests/io-channel-helpers.h
create mode 100644 tests/test-io-channel-command.c
create mode 100644 tests/test-io-channel-file.c
create mode 100644 tests/test-io-channel-socket.c
create mode 100644 tests/test-io-channel-tls.c
create mode 100644 tests/test-io-task.cSignature · 1 line
2.4.3
PATCH 1/46 sockets: add helpers for creating SocketAddress from a socket
Add two helper methods that, given a socket file descriptor, can return a populated SocketAddress struct containing either the local or remote address information.
--- include/qemu/sockets.h | 30 ++++++++++++++ util/qemu-sockets.c | 110 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 140 insertions(+)
include/qemu/sockets.h +30 -0
@@ -88,4 +88,34 @@ int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp);int parse_host_port (struct sockaddr_in *saddr,const char *str);int socket_init (void ); +/** +* socket_local_address: +* @fd: the socket file handle +* @errp: pointer to uninitialized error object +* +* Get the string representation of the local socket +* address. A pointer to the allocated address information +* struct will be returned, which the caller is required to +* release with a call qapi_free_SocketAddress when no +* longer required. +* +* Returns: the socket address struct, or NULL on error +*/ +SocketAddress *socket_local_address (int fd,Error **errp); + +/** +* socket_remote_address: +* @fd: the socket file handle +* @errp: pointer to uninitialized error object +* +* Get the string representation of the remote socket +* address. A pointer to the allocated address information +* struct will be returned, which the caller is required to +* release with a call qapi_free_SocketAddress when no +* longer required. +* +* Returns: the socket address struct, or NULL on error +*/ +SocketAddress *socket_remote_address (int fd,Error **errp); +#endif /* QEMU_SOCKET_H */
util/qemu-sockets.c +110 -0
113 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 2/46 sockets: move qapi_copy_SocketAddress into qemu-sockets.c
In reply to Daniel P. BerrangeThe qapi_copy_SocketAddress method is going to be useful in more places than just qemu-char.c, so move it into the qemu-sockets.c file to allow its reuse.
--- include/qemu/sockets.h | 4 ++++ qemu-char.c | 25 ------------------------- util/qemu-sockets.c | 30 ++++++++++++++++++++++++++++++ 3 files changed, 34 insertions(+), 25 deletions(-)
include/qemu/sockets.h +4 -0
@@ -118,4 +118,8 @@ SocketAddress *socket_local_address(int fd, Error **errp);*/ SocketAddress *socket_remote_address (int fd,Error **errp); + +void qapi_copy_SocketAddress (SocketAddress **p_dest, +SocketAddress *src); +#endif /* QEMU_SOCKET_H */
qemu-char.c +0 -25
@@ -93,31 +93,6 @@/***********************************************************/ /* Socket address helpers */ -static void qapi_copy_SocketAddress (SocketAddress **p_dest, -SocketAddress *src) -{ -QmpOutputVisitor *qov; -QmpInputVisitor *qiv; -Visitor *ov, *iv; -QObject *obj; - - *p_dest =NULL ; - - qov =qmp_output_visitor_new (); - ov =qmp_output_get_visitor (qov); -visit_type_SocketAddress (ov, &src,NULL , &error_abort); - obj =qmp_output_get_qobject (qov); -qmp_output_visitor_cleanup (qov); -if (!obj) { -return ; - } - - qiv =qmp_input_visitor_new (obj); - iv =qmp_input_get_visitor (qiv); -visit_type_SocketAddress (iv, p_dest,NULL , &error_abort); -qmp_input_visitor_cleanup (qiv); -qobject_decref (obj); -} static int SocketAddress_to_str(char *dest, int max_len, const char *prefix, SocketAddress *addr,
util/qemu-sockets.c +30 -0
@@ -25,6 +25,9 @@#include "monitor/monitor.h" #include "qemu/sockets.h" #include "qemu/main-loop.h" +#include "qapi/qmp-input-visitor.h" +#include "qapi/qmp-output-visitor.h" +#include "qapi-visit.h" #ifndef AI_ADDRCONFIG # define AI_ADDRCONFIG 0
@@ -1125,3 +1128,30 @@ SocketAddress *socket_remote_address(int fd, Error **errp)return socket_sockaddr_to_address (&ss, sslen, errp); } + + +void qapi_copy_SocketAddress (SocketAddress **p_dest, +SocketAddress *src) +{ +QmpOutputVisitor *qov; +QmpInputVisitor *qiv; +Visitor *ov, *iv; +QObject *obj; + + *p_dest =NULL ; + + qov =qmp_output_visitor_new (); + ov =qmp_output_get_visitor (qov); +visit_type_SocketAddress (ov, &src,NULL , &error_abort); + obj =qmp_output_get_qobject (qov); +qmp_output_visitor_cleanup (qov); +if (!obj) { +return ; + } + + qiv =qmp_input_visitor_new (obj); + iv =qmp_input_get_visitor (qiv); +visit_type_SocketAddress (iv, p_dest,NULL , &error_abort); +qmp_input_visitor_cleanup (qiv); +qobject_decref (obj); +}
Signature · 1 line
2.4.3
PATCH 3/46 sockets: allow port to be NULL when listening on IP address
In reply to Daniel P. BerrangeIf the port in the SocketAddress struct is NULL, it can allow the kernel to automatically select a free port. This is useful in particular in unit tests to avoid a race trying to find a free port to run a test case on.
--- util/qemu-sockets.c | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-)
util/qemu-sockets.c +13 -5
@@ -128,12 +128,15 @@ int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp) ai.ai_family =PF_UNSPEC ; ai.ai_socktype =SOCK_STREAM ; -if ((qemu_opt_get (opts,"host" ) ==NULL ) || - (qemu_opt_get (opts,"port" ) ==NULL )) { -error_setg (errp,"host and/or port not specified" ); +if ((qemu_opt_get (opts,"host" ) ==NULL )) { +error_setg (errp,"host not specified" );return -1 ; } -pstrcpy (port,sizeof (port),qemu_opt_get (opts,"port" )); +if (qemu_opt_get (opts,"port" ) !=NULL ) { +pstrcpy (port,sizeof (port),qemu_opt_get (opts,"port" )); + }else { + port[0 ] ='\0' ; + } addr =qemu_opt_get (opts,"host" ); to =qemu_opt_get_number (opts,"to" ,0 );
@@ -145,6 +148,10 @@ int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)/* lookup */ if (port_offset) {unsigned long long baseport; +if (strlen (port) ==0 ) { +error_setg (errp,"port not specified" ); +return -1 ; + }if (parse_uint_full (port, &baseport,10 ) <0 ) {error_setg (errp,"can't convert to a number: %s" , port);return -1 ;
@@ -156,7 +163,8 @@ int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp) }snprintf (port,sizeof (port),"%d" , (int )baseport + port_offset); } - rc =getaddrinfo (strlen (addr) ? addr :NULL , port, &ai, &res); + rc =getaddrinfo (strlen (addr) ? addr :NULL , +strlen (port) ? port :NULL , &ai, &res);if (rc !=0 ) {error_setg (errp,"address resolution failed for %s:%s: %s" , addr, port,gai_strerror (rc));
Signature · 1 line
2.4.3
PATCH 4/46 osdep: add qemu_fork() wrapper for safely handling signals
In reply to Daniel P. BerrangeWhen using regular fork() the child process of course inherits all the parents' signal handlers. If the child then proceeds to close() any open file descriptors, it may break some of those registered signal handlers. The child generally does not want to ever run any of the signal handlers tha parent may have installed in the short time before it exec's. The parent may also have blocked various signals which the child process will want enabled.
This introduces a wrapper qemu_fork() that takes care to sanitize signal handling across fork. Before forking it blocks all signals in the parent thread. After fork returns, the parent unblocks the signals and carries on as usual. The child, however, resets all the signal handlers back to their defaults before it unblocks signals. The child process can now exec the binary in a "clean" signal environment.
--- include/qemu/osdep.h | 16 ++++++++++++ util/oslib-posix.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++ util/oslib-win32.c | 9 +++++++ 3 files changed, 96 insertions(+)
include/qemu/osdep.h +16 -0
@@ -69,6 +69,8 @@#include "sysemu/os-posix.h" #endif +#include "qapi/error.h" +#if defined(CONFIG_SOLARIS ) &&CONFIG_SOLARIS_VERSION <10 /* [u]int_fast*_t not in <sys/int_types.h> */ typedef unsigned char uint_fast8_t ;
@@ -286,4 +288,18 @@ void os_mem_prealloc(int fd, char *area, size_t sz);int qemu_read_password (char *buf,int buf_size); +/** +* qemu_fork: +* +* A version of fork that avoids signal handler race +* conditions that can lead to child process getting +* signals that are otherwise only expected by the +* parent. It also resets all signal handlers to the +* default settings. +* +* Returns 0 to child process, pid number to parent +* or -1 on failure. +*/ +pid_t qemu_fork (Error **errp); +#endif
util/oslib-posix.c +71 -0
74 lines not on this page · raw message
util/oslib-win32.c +9 -0
@@ -496,3 +496,12 @@ int qemu_read_password(char *buf, int buf_size) buf[i] ='\0' ;return 0 ; } + + +pid_t qemu_fork (Error **errp) +{ + errno =ENOSYS ; +error_setg_errno (errp, errno, +"cannot fork child process" ); +return -1 ; +}
Signature · 1 line
2.4.3
PATCH 5/46 coroutine: move into libqemuutil.a library
In reply to Daniel P. BerrangeThe coroutine files are currently referenced by the block-obj-y variable. The coroutine functionality though is already used by more than just the block code. eg migration code uses coroutine yield. In the future the I/O channel code will also use the coroutine yield functionality. Since the coroutine code is nicely self-contained it can be easily built as part of the libqemuutil.a library, making it widely available.
The headers are also moved into include/qemu, instead of the include/block directory, since they are now part of the util codebase, and the impl was never in the block/ directory either.
---
Makefile.objs | 7 +++----
block.c | 2 +-
block/qcow2.h | 2 +-
block/vdi.c | 2 +-
block/write-threshold.c | 2 +-
blockjob.c | 2 +-
coroutine-gthread.c | 2 +-
coroutine-sigaltstack.c | 2 +-
coroutine-ucontext.c | 2 +-
coroutine-win32.c | 2 +-
hw/9pfs/codir.c | 2 +-
hw/9pfs/cofile.c | 2 +-
hw/9pfs/cofs.c | 2 +-
hw/9pfs/coxattr.c | 2 +-
hw/9pfs/virtio-9p-coth.c | 2 +-
hw/9pfs/virtio-9p-coth.h | 2 +-
hw/9pfs/virtio-9p.h | 2 +-
include/block/block.h | 2 +-
include/block/block_int.h | 2 +-
include/{block => qemu}/coroutine.h | 0
include/{block => qemu}/coroutine_int.h | 2 +-
migration/qemu-file-buf.c | 2 +-
migration/qemu-file-stdio.c | 2 +-
migration/qemu-file-unix.c | 2 +-
migration/qemu-file.c | 2 +-
migration/rdma.c | 2 +-
nbd.c | 2 +-
qemu-coroutine-io.c | 2 +-
qemu-coroutine-lock.c | 4 ++--
qemu-coroutine-sleep.c | 2 +-
qemu-coroutine.c | 4 ++--
tests/test-coroutine.c | 4 ++--
tests/test-vmstate.c | 2 +-
thread-pool.c | 2 +-
34 files changed, 38 insertions(+), 39 deletions(-)
rename include/{block => qemu}/coroutine.h (100%)
rename include/{block => qemu}/coroutine_int.h (98%)Makefile.objs +3 -4
@@ -2,6 +2,9 @@ # Common libraries for tools and emulators stub-obj-y = stubs/ util-obj-y = util/ qobject/ qapi/ qapi-types.o qapi-visit.o qapi-event.o +util-obj-y += qemu-coroutine.o qemu-coroutine-lock.o qemu-coroutine-io.o +util-obj-y += qemu-coroutine-sleep.o +util-obj-y += coroutine-$(CONFIG_COROUTINE_BACKEND).o ####################################################################### # block-obj-y is code used by both qemu system emulation and qemu-img
@@ -14,10 +17,6 @@ block-obj-$(CONFIG_WIN32) += aio-win32.o block-obj-y += block/ block-obj-y += qemu-io-cmds.o -block-obj-y += qemu-coroutine.o qemu-coroutine-lock.o qemu-coroutine-io.o -block-obj-y += qemu-coroutine-sleep.o -block-obj-y += coroutine-$(CONFIG_COROUTINE_BACKEND).o - block-obj-m = block/ #######################################################################
block.c +1 -1
@@ -33,7 +33,7 @@#include "sysemu/block-backend.h" #include "sysemu/sysemu.h" #include "qemu/notify.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "block/qapi.h" #include "qmp-commands.h" #include "qemu/timer.h"
block/qcow2.h +1 -1
@@ -26,7 +26,7 @@#define BLOCK_QCOW2_H #include "crypto/cipher.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" //#define DEBUG_ALLOC //#define DEBUG_ALLOC2
block/vdi.c +1 -1
@@ -53,7 +53,7 @@#include "block/block_int.h" #include "qemu/module.h" #include "migration/migration.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #if defined(CONFIG_UUID )#include <uuid/uuid.h>
block/write-threshold.c +1 -1
@@ -11,7 +11,7 @@*/ #include "block/block_int.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "block/write-threshold.h" #include "qemu/notify.h" #include "qapi-event.h"
blockjob.c +1 -1
@@ -31,7 +31,7 @@#include "block/block_int.h" #include "qapi/qmp/qerror.h" #include "qapi/qmp/qjson.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "qmp-commands.h" #include "qemu/timer.h" #include "qapi-event.h"
coroutine-gthread.c +1 -1
@@ -20,7 +20,7 @@#include <glib.h> #include "qemu-common.h" -#include "block/coroutine_int.h" +#include "qemu/coroutine_int.h" typedef struct { Coroutine base;
coroutine-sigaltstack.c +1 -1
@@ -31,7 +31,7 @@#include <pthread.h> #include <signal.h> #include "qemu-common.h" -#include "block/coroutine_int.h" +#include "qemu/coroutine_int.h" typedef struct { Coroutine base;
coroutine-ucontext.c +1 -1
@@ -27,7 +27,7 @@#include <stdint.h> #include <ucontext.h> #include "qemu-common.h" -#include "block/coroutine_int.h" +#include "qemu/coroutine_int.h" #ifdef CONFIG_VALGRIND_H #include <valgrind/valgrind.h>
coroutine-win32.c +1 -1
@@ -23,7 +23,7 @@*/ #include "qemu-common.h" -#include "block/coroutine_int.h" +#include "qemu/coroutine_int.h" typedef struct {
hw/9pfs/codir.c +1 -1
@@ -14,7 +14,7 @@#include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "virtio-9p-coth.h" int v9fs_co_readdir_r(V9fsPDU *pdu, V9fsFidState *fidp, struct dirent *dent,
hw/9pfs/cofile.c +1 -1
@@ -14,7 +14,7 @@#include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "virtio-9p-coth.h" int v9fs_co_st_gen(V9fsPDU *pdu, V9fsPath *path, mode_t st_mode,
hw/9pfs/cofs.c +1 -1
@@ -14,7 +14,7 @@#include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "virtio-9p-coth.h" static ssize_t __readlink (V9fsState *s,V9fsPath *path,V9fsString *buf)
hw/9pfs/coxattr.c +1 -1
@@ -14,7 +14,7 @@#include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "virtio-9p-coth.h" int v9fs_co_llistxattr (V9fsPDU *pdu,V9fsPath *path,void *value,size_t size)
hw/9pfs/virtio-9p-coth.c +1 -1
@@ -15,7 +15,7 @@#include "fsdev/qemu-fsdev.h" #include "qemu/thread.h" #include "qemu/event_notifier.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "virtio-9p-coth.h" /* v9fs glib thread pool */
hw/9pfs/virtio-9p-coth.h +1 -1
@@ -16,7 +16,7 @@#define _QEMU_VIRTIO_9P_COTH_H#include "qemu/thread.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "virtio-9p.h" #include <glib.h>
hw/9pfs/virtio-9p.h +1 -1
@@ -13,7 +13,7 @@#include "fsdev/file-op-9p.h" #include "fsdev/virtio-9p-marshal.h" #include "qemu/thread.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" enum {P9_TLERROR =6 ,
include/block/block.h +1 -1
@@ -4,7 +4,7 @@#include "block/aio.h" #include "qemu-common.h" #include "qemu/option.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "block/accounting.h" #include "qapi/qmp/qobject.h" #include "qapi-types.h"
include/block/block_int.h +1 -1
@@ -28,7 +28,7 @@#include "block/block.h" #include "qemu/option.h" #include "qemu/queue.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "qemu/timer.h" #include "qapi-types.h" #include "qemu/hbitmap.h"
include/qemu/coroutine.h renamed from include/block/coroutine.h +0 -0
include/qemu/coroutine_int.h renamed from include/block/coroutine_int.h +1 -1
@@ -26,7 +26,7 @@#define QEMU_COROUTINE_INT_H #include "qemu/queue.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" typedef enum { COROUTINE_YIELD = 1,
migration/qemu-file-buf.c +1 -1
@@ -29,7 +29,7 @@#include "qemu/error-report.h" #include "qemu/iov.h" #include "qemu/sockets.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "migration/migration.h" #include "migration/qemu-file.h" #include "migration/qemu-file-internal.h"
migration/qemu-file-stdio.c +1 -1
@@ -22,7 +22,7 @@* THE SOFTWARE. */ #include "qemu-common.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "migration/qemu-file.h" typedef struct QEMUFileStdio {
migration/qemu-file-unix.c +1 -1
@@ -24,7 +24,7 @@#include "qemu-common.h" #include "qemu/iov.h" #include "qemu/sockets.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "migration/qemu-file.h" #include "migration/qemu-file-internal.h"
migration/qemu-file.c +1 -1
@@ -26,7 +26,7 @@#include "qemu/error-report.h" #include "qemu/iov.h" #include "qemu/sockets.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "migration/migration.h" #include "migration/qemu-file.h" #include "migration/qemu-file-internal.h"
migration/rdma.c +1 -1
@@ -19,7 +19,7 @@#include "qemu/main-loop.h" #include "qemu/sockets.h" #include "qemu/bitmap.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include <stdio.h> #include <sys/types.h> #include <sys/socket.h>
nbd.c +1 -1
@@ -19,7 +19,7 @@#include "block/nbd.h" #include "sysemu/block-backend.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include <errno.h> #include <string.h>
qemu-coroutine-io.c +1 -1
@@ -24,7 +24,7 @@*/ #include "qemu-common.h" #include "qemu/sockets.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "qemu/iov.h" #include "qemu/main-loop.h"
qemu-coroutine-lock.c +2 -2
@@ -23,8 +23,8 @@*/ #include "qemu-common.h" -#include "block/coroutine.h" -#include "block/coroutine_int.h" +#include "qemu/coroutine.h" +#include "qemu/coroutine_int.h" #include "qemu/queue.h" #include "trace.h"
qemu-coroutine-sleep.c +1 -1
@@ -11,7 +11,7 @@* */ -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "qemu/timer.h" #include "block/aio.h"
qemu-coroutine.c +2 -2
@@ -16,8 +16,8 @@#include "qemu-common.h" #include "qemu/thread.h" #include "qemu/atomic.h" -#include "block/coroutine.h" -#include "block/coroutine_int.h" +#include "qemu/coroutine.h" +#include "qemu/coroutine_int.h" enum {POOL_BATCH_SIZE =64 ,
tests/test-coroutine.c +2 -2
@@ -12,8 +12,8 @@*/ #include <glib.h> -#include "block/coroutine.h" -#include "block/coroutine_int.h" +#include "qemu/coroutine.h" +#include "qemu/coroutine_int.h" /* * Check that qemu_in_coroutine() works
tests/test-vmstate.c +1 -1
@@ -27,7 +27,7 @@#include "qemu-common.h" #include "migration/migration.h" #include "migration/vmstate.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" static char temp_file[] ="/tmp/vmst.test.XXXXXX" ;static int temp_fd;
thread-pool.c +1 -1
@@ -18,7 +18,7 @@#include "qemu/queue.h" #include "qemu/thread.h" #include "qemu/osdep.h" -#include "block/coroutine.h" +#include "qemu/coroutine.h" #include "trace.h" #include "block/thread-pool.h" #include "qemu/main-loop.h"
Signature · 1 line
2.4.3
PATCH 6/46 io: add abstract QIOChannel classes
In reply to Daniel P. BerrangeStart the new generic I/O channel framework by defining a QIOChannel abstract base class. This is designed to feel similar to GLib's GIOChannel, but with the addition of support for using iovecs, qemu error reporting, file descriptor passing, coroutine integration and use of the QOM framework for easier sub-classing.
The intention is that anywhere in QEMU that almost anywhere that deals with sockets will use this new I/O infrastructure, so that it becomes trivial to then layer in support for TLS encryption. This will at least include the VNC server, char device backend and migration code.
--- MAINTAINERS | 7 + Makefile | 2 + Makefile.objs | 5 + Makefile.target | 2 + include/io/channel.h | 374 +++++++++++++++++++++++++++++++++++++++++++++++++++ io/Makefile.objs | 1 + io/channel.c | 229 +++++++++++++++++++++++++++++++ 7 files changed, 620 insertions(+) create mode 100644 include/io/channel.h create mode 100644 io/Makefile.objs create mode 100644 io/channel.c
MAINTAINERS +7 -0
@@ -1078,6 +1078,13 @@ F: crypto/ F: include/crypto/ F: tests/test-crypto-* +I/O Channels +M: Daniel P. Berrange <[email protected]> +S: Maintained +F: io/ +F: include/io/ +F: tests/test-io-* + Usermode Emulation ------------------ Overall
Makefile +2 -0
@@ -153,6 +153,7 @@ dummy := $(call unnest-vars,, \ block-obj-m \ crypto-obj-y \ qom-obj-y \ + io-obj-y \ common-obj-y \ common-obj-m)
@@ -176,6 +177,7 @@ SOFTMMU_SUBDIR_RULES=$(filter %-softmmu,$(SUBDIR_RULES)) $(SOFTMMU_SUBDIR_RULES): $(block-obj-y) $(SOFTMMU_SUBDIR_RULES): $(crypto-obj-y) $(SOFTMMU_SUBDIR_RULES): $(qom-obj-y) +$(SOFTMMU_SUBDIR_RULES): $(io-obj-y) $(SOFTMMU_SUBDIR_RULES): config-all-devices.mak subdir-%:
Makefile.objs +5 -0
@@ -29,6 +29,11 @@ crypto-obj-y = crypto/ qom-obj-y = qom/ +####################################################################### +# io-obj-y is code used by both qemu system emulation and qemu-img + +io-obj-y = io/ + ###################################################################### # smartcard
Makefile.target +2 -0
@@ -172,6 +172,7 @@ dummy := $(call unnest-vars,.., \ block-obj-m \ crypto-obj-y \ qom-obj-y \ + io-obj-y \ common-obj-y \ common-obj-m) target-obj-y := $(target-obj-y-save)
@@ -180,6 +181,7 @@ all-obj-y += $(target-obj-y) all-obj-$(CONFIG_SOFTMMU) += $(block-obj-y) all-obj-$(CONFIG_SOFTMMU) += $(crypto-obj-y) all-obj-$(CONFIG_SOFTMMU) += $(qom-obj-y) +all-obj-$(CONFIG_SOFTMMU) += $(io-obj-y) $(QEMU_PROG_BUILD): config-devices.mak
include/io/channel.h new file +374 -0
374 lines not on this page · raw message
io/Makefile.objs new file +1 -0
@@ -0,0 +1 @@ +io-obj-y = channel.o
io/channel.c new file +229 -0
229 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 7/46 io: add helper module for creating watches on FDs
In reply to Daniel P. BerrangeA number of the channel implementations will require the ability to create watches on file descriptors / sockets. To avoid duplicating this code in each channel, provide a helper API for dealing with file descriptor watches.
There are two watch implementations provided. The first is useful for bi-directional file descriptors such as sockets, regular files, character devices, etc. The second works with a pair of unidirectional file descriptors such as pipes.
--- include/io/channel-watch.h | 72 ++++++++++++++++ io/Makefile.objs | 1 + io/channel-watch.c | 200 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 273 insertions(+) create mode 100644 include/io/channel-watch.h create mode 100644 io/channel-watch.c
include/io/channel-watch.h new file +72 -0
@@ -0,0 +1,72 @@ +/* +* QEMU I/O channels watch helper APIs +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QIO_CHANNEL_WATCH_H__ +#define QIO_CHANNEL_WATCH_H__ + +#include "io/channel.h" + +/* +* This module provides helper functions that will be needed by +* the various QIOChannel implementations, for creating watches +* on file descriptors / sockets +*/ + +/** +* qio_channel_create_fd_watch: +* @ioc: the channel object +* @fd: the file descriptor +* @condition: the I/O condition +* +* Create a new main loop source that is able to +* monitor the file descriptor @fd for the +* I/O conditions in @condition. This is able +* monitor block devices, character devices, +* sockets, pipes but not plain files. +* +* Returns: the new main loop source +*/ +GSource *qio_channel_create_fd_watch (QIOChannel *ioc, +int fd, +GIOCondition condition); + +/** +* qio_channel_create_fd_pair_watch: +* @ioc: the channel object +* @fdread: the file descriptor for reading +* @fdwrite: the file descriptor for writing +* @condition: the I/O condition +* +* Create a new main loop source that is able to +* monitor the pair of file descriptors @fdread +* and @fdwrite for the I/O conditions in @condition. +* This is intended for monitoring unidirectional +* file descriptors such as pipes, where a pair +* of descriptors is required for bidirectional +* I/O +* +* Returns: the new main loop source +*/ +GSource *qio_channel_create_fd_pair_watch (QIOChannel *ioc, +int fdread, +int fdwrite, +GIOCondition condition); + +#endif /* QIO_CHANNEL_WATCH_H__ */
io/Makefile.objs +1 -0
@@ -1 +1,2 @@ io-obj-y = channel.o +io-obj-y += channel-watch.o
io/channel-watch.c new file +200 -0
200 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 8/46 io: pull Buffer code out of VNC module
In reply to Daniel P. BerrangeThe Buffer code in the VNC server is useful for the IO channel code, so pull it out into a shared module, QIOBuffer.
--- include/io/buffer.h | 118 ++++++++++++++++++++++++++++++++++++++++++++++++++++ io/Makefile.objs | 3 +- io/buffer.c | 65 +++++++++++++++++++++++++++++ ui/vnc-auth-sasl.c | 4 +- ui/vnc-enc-tight.c | 38 ++++++++--------- ui/vnc-enc-zlib.c | 6 +-- ui/vnc-enc-zrle.c | 18 ++++---- ui/vnc-jobs.c | 15 +++---- ui/vnc-ws.c | 36 ++++++++-------- ui/vnc-ws.h | 6 +-- ui/vnc.c | 67 ++++++----------------------- ui/vnc.h | 50 ++++++++-------------- 12 files changed, 277 insertions(+), 149 deletions(-) create mode 100644 include/io/buffer.h create mode 100644 io/buffer.c
include/io/buffer.h new file +118 -0
@@ -0,0 +1,118 @@ +/* +* QEMU I/O buffers +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QIO_BUFFER_H__ +#define QIO_BUFFER_H__ + +#include "qemu-common.h" + +typedef struct QIOBuffer QIOBuffer ; + +/** +* QIOBuffer: +* +* The QIOBuffer object provides a simple dynamically resizing +* array, with separate tracking of capacity and usage. This +* is typically useful when buffering I/O data. +*/ + +struct QIOBuffer { +size_t capacity; +size_t offset; +uint8_t *buffer; +}; + +/** +* qio_buffer_reserve: +* @buffer: the buffer object +* @len: the minimum required free space +* +* Ensure that the buffer has space allocated for at least +* @len bytes. If the current buffer is too small, it will +* be reallocated, possibly to a larger size than requested. +*/ +void qio_buffer_reserve (QIOBuffer *buffer,size_t len); + +/** +* qio_buffer_reset: +* @buffer: the buffer object +* +* Reset the length of the stored data to zero, but do +* not free / reallocate the memory buffer +*/ +void qio_buffer_reset (QIOBuffer *buffer); + +/** +* qio_buffer_free: +* @buffer: the buffer object +* +* Reset the length of the stored data to zero and also +* free the internal memory buffer +*/ +void qio_buffer_free (QIOBuffer *buffer); + +/** +* qio_buffer_append: +* @buffer: the buffer object +* @data: the data block to append +* @len: the length of @data in bytes +* +* Append the contents of @data to the end of the buffer. +* The caller must ensure that the buffer has sufficient +* free space for @len bytes, typically by calling the +* qio_buffer_reserve() method prior to appending. +*/ +void qio_buffer_append (QIOBuffer *buffer,const void *data,size_t len); + +/** +* qio_buffer_advance: +* @buffer: the buffer object +* @len: the number of bytes to skip +* +* Remove @len bytes of data from the head of the buffer. +* The internal buffer will not be reallocated, so will +* have at least @len bytes of free space after this +* call completes +*/ +void qio_buffer_advance (QIOBuffer *buffer,size_t len); + +/** +* qio_buffer_end: +* @buffer: the buffer object +* +* Get a pointer to the tail end of the internal buffer +* The returned pointer is only valid until the next +* call to qio_buffer_reserve(). +* +* Returns: the tail of the buffer +*/ +uint8_t *qio_buffer_end (QIOBuffer *buffer); + +/** +* qio_buffer_empty: +* @buffer: the buffer object +* +* Determine if the buffer contains any current data +* +* Returns: true if the buffer holds data, false otherwise +*/ +gboolean qio_buffer_empty (QIOBuffer *buffer); + +#endif /* QIO_BUFFER_H__ */
io/Makefile.objs +2 -1
@@ -1,2 +1,3 @@ -io-obj-y = channel.o +io-obj-y = buffer.o +io-obj-y += channel.o io-obj-y += channel-watch.o
io/buffer.c new file +65 -0
65 lines not on this page · raw message
ui/vnc-auth-sasl.c +2 -2
@@ -113,8 +113,8 @@ long vnc_client_read_sasl(VncState *vs)return vnc_client_io_error (vs,-1 , -EIO );VNC_DEBUG ("Read SASL Encoded %p size %ld Decoded %p size %d\n" , encoded, ret, decoded, decodedLen); -buffer_reserve (&vs->input, decodedLen); -buffer_append (&vs->input, decoded, decodedLen); +qio_buffer_reserve (&vs->input, decodedLen); +qio_buffer_append (&vs->input, decoded, decodedLen);return decodedLen; }
ui/vnc-enc-tight.c +19 -19
@@ -856,7 +856,7 @@ static int tight_compress_data(VncState *vs, int stream_id, size_t bytes, }/* reserve memory in output buffer */ -buffer_reserve (&vs->tight.zlib, bytes +64 ); +qio_buffer_reserve (&vs->tight.zlib, bytes +64 );/* set pointers */ zstream->next_in = vs->tight.tight.buffer;
@@ -879,7 +879,7 @@ static int tight_compress_data(VncState *vs, int stream_id, size_t bytes,tight_send_compact_size (vs, bytes);vnc_write (vs, vs->tight.zlib.buffer, bytes); -buffer_reset (&vs->tight.zlib); +qio_buffer_reset (&vs->tight.zlib);return bytes; }
@@ -1053,7 +1053,7 @@ static bool send_gradient_rect(VncState *vs, int x, int y, int w, int h)vnc_write_u8 (vs, (stream |VNC_TIGHT_EXPLICIT_FILTER ) <<4 );vnc_write_u8 (vs,VNC_TIGHT_FILTER_GRADIENT ); -buffer_reserve (&vs->tight.gradient, w *3 *sizeof (int )); +qio_buffer_reserve (&vs->tight.gradient, w *3 *sizeof (int ));if (vs->tight.pixel24) {tight_filter_gradient24 (vs, vs->tight.tight.buffer, w, h);
@@ -1066,7 +1066,7 @@ static bool send_gradient_rect(VncState *vs, int x, int y, int w, int h) bytes =2 ; } -buffer_reset (&vs->tight.gradient); +qio_buffer_reset (&vs->tight.gradient); bytes = w * h * bytes; vs->tight.tight.offset = bytes;
@@ -1149,7 +1149,7 @@ static int send_palette_rect(VncState *vs, int x, int y,static void jpeg_init_destination (j_compress_ptr cinfo) {VncState *vs = cinfo->client_data; -Buffer *buffer = &vs->tight.jpeg; +QIOBuffer *buffer = &vs->tight.jpeg; cinfo->dest->next_output_byte = (JOCTET *)buffer->buffer + buffer->offset; cinfo->dest->free_in_buffer = (size_t )(buffer->capacity - buffer->offset);
@@ -1159,10 +1159,10 @@ static void jpeg_init_destination(j_compress_ptr cinfo)static boolean jpeg_empty_output_buffer (j_compress_ptr cinfo) {VncState *vs = cinfo->client_data; -Buffer *buffer = &vs->tight.jpeg; +QIOBuffer *buffer = &vs->tight.jpeg; buffer->offset = buffer->capacity; -buffer_reserve (buffer,2048 ); +qio_buffer_reserve (buffer,2048 );jpeg_init_destination (cinfo);return TRUE; }
@@ -1171,7 +1171,7 @@ static boolean jpeg_empty_output_buffer(j_compress_ptr cinfo)static void jpeg_term_destination (j_compress_ptr cinfo) {VncState *vs = cinfo->client_data; -Buffer *buffer = &vs->tight.jpeg; +QIOBuffer *buffer = &vs->tight.jpeg; buffer->offset = buffer->capacity - cinfo->dest->free_in_buffer; }
@@ -1190,7 +1190,7 @@ static int send_jpeg_rect(VncState *vs, int x, int y, int w, int h, int quality)return send_full_color_rect (vs, x, y, w, h); } -buffer_reserve (&vs->tight.jpeg,2048 ); +qio_buffer_reserve (&vs->tight.jpeg,2048 ); cinfo.err =jpeg_std_error (&jerr);jpeg_create_compress (&cinfo);
@@ -1227,7 +1227,7 @@ static int send_jpeg_rect(VncState *vs, int x, int y, int w, int h, int quality)tight_send_compact_size (vs, vs->tight.jpeg.offset);vnc_write (vs, vs->tight.jpeg.buffer, vs->tight.jpeg.offset); -buffer_reset (&vs->tight.jpeg); +qio_buffer_reset (&vs->tight.jpeg);return 1 ; }
@@ -1270,7 +1270,7 @@ static void png_write_data(png_structp png_ptr, png_bytep data, {VncState *vs =png_get_io_ptr (png_ptr); -buffer_reserve (&vs->tight.png, vs->tight.png.offset + length); +qio_buffer_reserve (&vs->tight.png, vs->tight.png.offset + length);memcpy (vs->tight.png.buffer + vs->tight.png.offset, data, length); vs->tight.png.offset += length;
@@ -1351,7 +1351,7 @@ static int send_png_rect(VncState *vs, int x, int y, int w, int h,png_write_info (png_ptr, info_ptr); -buffer_reserve (&vs->tight.png,2048 ); +qio_buffer_reserve (&vs->tight.png,2048 ); linebuf =qemu_pixman_linebuf_create (PIXMAN_BE_r8g8b8, w); buf = (uint8_t *)pixman_image_get_data (linebuf);for (dy =0 ; dy < h; dy++)
@@ -1377,14 +1377,14 @@ static int send_png_rect(VncState *vs, int x, int y, int w, int h,tight_send_compact_size (vs, vs->tight.png.offset);vnc_write (vs, vs->tight.png.buffer, vs->tight.png.offset); -buffer_reset (&vs->tight.png); +qio_buffer_reset (&vs->tight.png); return 1; }#endif /* CONFIG_VNC_PNG */ static void vnc_tight_start (VncState *vs) { -buffer_reset (&vs->tight.tight); +qio_buffer_reset (&vs->tight.tight);// make the output buffer be the zlib buffer, so we can compress it later vs->tight.tmp = vs->output;
@@ -1686,13 +1686,13 @@ void vnc_tight_clear(VncState *vs) } } -buffer_free (&vs->tight.tight); -buffer_free (&vs->tight.zlib); -buffer_free (&vs->tight.gradient); +qio_buffer_free (&vs->tight.tight); +qio_buffer_free (&vs->tight.zlib); +qio_buffer_free (&vs->tight.gradient);#ifdef CONFIG_VNC_JPEG -buffer_free (&vs->tight.jpeg); +qio_buffer_free (&vs->tight.jpeg);#endif #ifdef CONFIG_VNC_PNG -buffer_free (&vs->tight.png); +qio_buffer_free (&vs->tight.png);#endif }
ui/vnc-enc-zlib.c +3 -3
@@ -47,7 +47,7 @@ void vnc_zlib_zfree(void *x, void *addr)static void vnc_zlib_start (VncState *vs) { -buffer_reset (&vs->zlib.zlib); +qio_buffer_reset (&vs->zlib.zlib);// make the output buffer be the zlib buffer, so we can compress it later vs->zlib.tmp = vs->output;
@@ -96,7 +96,7 @@ static int vnc_zlib_stop(VncState *vs) }// reserve memory in output buffer -buffer_reserve (&vs->output, vs->zlib.zlib.offset +64 ); +qio_buffer_reserve (&vs->output, vs->zlib.zlib.offset +64 );// set pointers zstream->next_in = vs->zlib.zlib.buffer;
@@ -148,5 +148,5 @@ void vnc_zlib_clear(VncState *vs)if (vs->zlib.stream.opaque) {deflateEnd (&vs->zlib.stream); } -buffer_free (&vs->zlib.zlib); +qio_buffer_free (&vs->zlib.zlib); }
ui/vnc-enc-zrle.c +9 -9
@@ -36,7 +36,7 @@ static const int bits_per_packed_pixel[] = {static void vnc_zrle_start (VncState *vs) { -buffer_reset (&vs->zrle.zrle); +qio_buffer_reset (&vs->zrle.zrle);/* make the output buffer be the zlib buffer, so we can compress it later */ vs->zrle.tmp = vs->output;
@@ -53,10 +53,10 @@ static void vnc_zrle_stop(VncState *vs)static void *zrle_convert_fb (VncState *vs,int x,int y,int w,int h,int bpp) { -Buffer tmp; +QIOBuffer tmp; -buffer_reset (&vs->zrle.fb); -buffer_reserve (&vs->zrle.fb, w * h * bpp + bpp); +qio_buffer_reset (&vs->zrle.fb); +qio_buffer_reserve (&vs->zrle.fb, w * h * bpp + bpp); tmp = vs->output; vs->output = vs->zrle.fb;
@@ -72,7 +72,7 @@ static int zrle_compress_data(VncState *vs, int level) {z_streamp zstream = &vs->zrle.stream; -buffer_reset (&vs->zrle.zlib); +qio_buffer_reset (&vs->zrle.zlib);if (zstream->opaque != vs) {int err;
@@ -92,7 +92,7 @@ static int zrle_compress_data(VncState *vs, int level) }/* reserve memory in output buffer */ -buffer_reserve (&vs->zrle.zlib, vs->zrle.zrle.offset +64 ); +qio_buffer_reserve (&vs->zrle.zlib, vs->zrle.zrle.offset +64 );/* set pointers */ zstream->next_in = vs->zrle.zrle.buffer;
@@ -360,7 +360,7 @@ void vnc_zrle_clear(VncState *vs)if (vs->zrle.stream.opaque) {deflateEnd (&vs->zrle.stream); } -buffer_free (&vs->zrle.zrle); -buffer_free (&vs->zrle.fb); -buffer_free (&vs->zrle.zlib); +qio_buffer_free (&vs->zrle.zrle); +qio_buffer_free (&vs->zrle.fb); +qio_buffer_free (&vs->zrle.zlib); }
ui/vnc-jobs.c +8 -7
@@ -54,7 +54,7 @@ struct VncJobQueue {QemuCond cond;QemuMutex mutex;QemuThread thread; -Buffer buffer; +QIOBuffer buffer;bool exit; QTAILQ_HEAD(, VncJob) jobs; };
@@ -167,7 +167,7 @@ void vnc_jobs_consume_buffer(VncState *vs)vnc_lock_output (vs);if (vs->jobs_buffer.offset) {vnc_write (vs, vs->jobs_buffer.buffer, vs->jobs_buffer.offset); -buffer_reset (&vs->jobs_buffer); +qio_buffer_reset (&vs->jobs_buffer); } flush = vs->csock !=-1 && vs->abort != true;vnc_unlock_output (vs);
@@ -196,7 +196,7 @@ static void vnc_async_encoding_start(VncState *orig, VncState *local) local->output = queue->buffer; local->csock =-1 ;/* Don't do any network work on this thread */ -buffer_reset (&local->output); +qio_buffer_reset (&local->output); }static void vnc_async_encoding_end (VncState *orig,VncState *local)
@@ -273,10 +273,11 @@ static int vnc_worker_thread_loop(VncJobQueue *queue) vs.output.buffer[saved_offset +1 ] = n_rectangles &0xFF ;vnc_lock_output (job->vs); +if (job->vs->csock !=-1 ) { -buffer_reserve (&job->vs->jobs_buffer, vs.output.offset); -buffer_append (&job->vs->jobs_buffer, vs.output.buffer, - vs.output.offset); +qio_buffer_reserve (&job->vs->jobs_buffer, vs.output.offset); +qio_buffer_append (&job->vs->jobs_buffer, vs.output.buffer, + vs.output.offset);/* Copy persistent encoding data */ vnc_async_encoding_end (job->vs, &vs);
@@ -310,7 +311,7 @@ static void vnc_queue_clear(VncJobQueue *q) {qemu_cond_destroy (&queue->cond);qemu_mutex_destroy (&queue->mutex); -buffer_free (&queue->buffer); +qio_buffer_free (&queue->buffer);g_free (q); queue =NULL ;/* Unset global queue */ }
ui/vnc-ws.c +18 -18
@@ -95,8 +95,8 @@ void vncws_handshake_read(void *opaque)/* Typical HTTP headers from novnc are 512 bytes, so limiting * total header size to 4096 is easily enough. */ size_t want =4096 - vs->ws_input.offset; -buffer_reserve (&vs->ws_input, want); - ret =vnc_client_read_buf (vs,buffer_end (&vs->ws_input), want); +qio_buffer_reserve (&vs->ws_input, want); + ret =vnc_client_read_buf (vs,qio_buffer_end (&vs->ws_input), want);if (!ret) {if (vs->csock ==-1 ) {
@@ -111,7 +111,7 @@ void vncws_handshake_read(void *opaque)if (handshake_end) {qemu_set_fd_handler (vs->csock, vnc_client_read,NULL , vs);vncws_process_handshake (vs, vs->ws_input.buffer, vs->ws_input.offset); -buffer_advance (&vs->ws_input, handshake_end - vs->ws_input.buffer + +qio_buffer_advance (&vs->ws_input, handshake_end - vs->ws_input.buffer +strlen (WS_HANDSHAKE_END )); }else if (vs->ws_input.offset >=4096 ) {VNC_DEBUG ("End of headers not found in first 4096 bytes\n" );
@@ -127,8 +127,8 @@ long vnc_client_read_ws(VncState *vs)size_t payload_size, header_size;VNC_DEBUG ("Read websocket %p size %zd offset %zd\n" , vs->ws_input.buffer, vs->ws_input.capacity, vs->ws_input.offset); -buffer_reserve (&vs->ws_input,4096 ); - ret =vnc_client_read_buf (vs,buffer_end (&vs->ws_input),4096 ); +qio_buffer_reserve (&vs->ws_input,4096 ); + ret =vnc_client_read_buf (vs,qio_buffer_end (&vs->ws_input),4096 );if (!ret) {return 0 ; }
@@ -146,7 +146,7 @@ long vnc_client_read_ws(VncState *vs)return err; } -buffer_advance (&vs->ws_input, header_size); +qio_buffer_advance (&vs->ws_input, header_size); }if (vs->ws_payload_remain !=0 ) { err = vncws_decode_frame_payload(&vs->ws_input,
@@ -162,10 +162,10 @@ long vnc_client_read_ws(VncState *vs) } ret += err; -buffer_reserve (&vs->input, payload_size); -buffer_append (&vs->input, payload, payload_size); +qio_buffer_reserve (&vs->input, payload_size); +qio_buffer_append (&vs->input, payload, payload_size); -buffer_advance (&vs->ws_input, payload_size); +qio_buffer_advance (&vs->ws_input, payload_size); } }while (vs->ws_input.offset >0 );
@@ -178,13 +178,13 @@ long vnc_client_write_ws(VncState *vs)VNC_DEBUG ("Write WS: Pending output %p size %zd offset %zd\n" , vs->output.buffer, vs->output.capacity, vs->output.offset);vncws_encode_frame (&vs->ws_output, vs->output.buffer, vs->output.offset); -buffer_reset (&vs->output); +qio_buffer_reset (&vs->output); ret =vnc_client_write_buf (vs, vs->ws_output.buffer, vs->ws_output.offset);if (!ret) {return 0 ; } -buffer_advance (&vs->ws_output, ret); +qio_buffer_advance (&vs->ws_output, ret);if (vs->ws_output.offset ==0 ) {qemu_set_fd_handler (vs->csock, vnc_client_read,NULL , vs);
@@ -267,8 +267,8 @@ void vncws_process_handshake(VncState *vs, uint8_t *line, size_t size)g_free (key); } -void vncws_encode_frame (Buffer *output,const void *payload, -const size_t payload_size) +void vncws_encode_frame (QIOBuffer *output,const void *payload, +const size_t payload_size) {size_t header_size =0 ;unsigned char opcode =WS_OPCODE_BINARY_FRAME ;
@@ -295,12 +295,12 @@ void vncws_encode_frame(Buffer *output, const void *payload, header_size =10 ; } -buffer_reserve (output, header_size + payload_size); -buffer_append (output, header.buf, header_size); -buffer_append (output, payload, payload_size); +qio_buffer_reserve (output, header_size + payload_size); +qio_buffer_append (output, header.buf, header_size); +qio_buffer_append (output, payload, payload_size); } -int vncws_decode_frame_header (Buffer *input, +int vncws_decode_frame_header (QIOBuffer *input,size_t *header_size,size_t *payload_remain,WsMask *payload_mask)
@@ -354,7 +354,7 @@ int vncws_decode_frame_header(Buffer *input,return 1 ; } -int vncws_decode_frame_payload (Buffer *input, +int vncws_decode_frame_payload (QIOBuffer *input,size_t *payload_remain,WsMask *payload_mask,uint8_t **payload,size_t *payload_size) {
ui/vnc-ws.h +3 -3
@@ -77,13 +77,13 @@ void vncws_handshake_read(void *opaque);long vnc_client_write_ws (VncState *vs);long vnc_client_read_ws (VncState *vs);void vncws_process_handshake (VncState *vs,uint8_t *line,size_t size); -void vncws_encode_frame (Buffer *output,const void *payload, +void vncws_encode_frame (QIOBuffer *output,const void *payload,const size_t payload_size); -int vncws_decode_frame_header (Buffer *input, +int vncws_decode_frame_header (QIOBuffer *input,size_t *header_size,size_t *payload_remain,WsMask *payload_mask); -int vncws_decode_frame_payload (Buffer *input, +int vncws_decode_frame_payload (QIOBuffer *input,size_t *payload_remain,WsMask *payload_mask,uint8_t **payload,size_t *payload_size);
ui/vnc.c +12 -55
113 lines not on this page · raw message
ui/vnc.h +18 -32
101 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 9/46 io: add QIOTask class for async operations
In reply to Daniel P. BerrangeA number of I/O operations need to be performed asynchronously to avoid blocking the main loop. The caller of such APIs need to provide a callback to be invoked on completion/error and need access to the error, if any. The small QIOTask provides a simple framework for dealing with such probes. The API docs inline provide an outline of how this is to be used.
Some functions don't have the ability to run asynchronously (eg getaddrinfo always blocks), so to facilitate their use, the task class provides a mechanism to run a blocking function in a thread, while triggering the completion callback in the main event loop thread. This easily allows any synchronous function to be made asynchronous, albeit at the cost of spawning a thread.
In this series, the QIOTask class will be used for things like the TLS handshake, the websockets handshake and TCP connect() progress.
The concept of QIOTask is inspired by the GAsyncResult interface / GTask class in the GIO libraries. The min version requirements on glib don't allow those to be used from QEMU, so QIOTask provides a facsimilie which can be easily switched to GTask in the future if the min version is increased.
--- include/io/task.h | 256 +++++++++++++++++++++++++++++++++++++++++++++++ io/Makefile.objs | 1 + io/task.c | 150 ++++++++++++++++++++++++++++ tests/.gitignore | 1 + tests/Makefile | 3 + tests/test-io-task.c | 276 +++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 687 insertions(+) create mode 100644 include/io/task.h create mode 100644 io/task.c create mode 100644 tests/test-io-task.c
include/io/task.h new file +256 -0
@@ -0,0 +1,256 @@ +/* +* QEMU I/O task +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QIO_TASK_H__ +#define QIO_TASK_H__ + +#include "qemu-common.h" +#include "qapi/error.h" +#include "qom/object.h" + +typedef struct QIOTask QIOTask ; + +typedef void (*QIOTaskFunc )(Object *source, +Error *err, +gpointer opaque); + +typedef int (*QIOTaskWorker )(QIOTask *task, +Error **errp, +gpointer opaque); + +/** +* QIOTask: +* +* The QIOTask object provides a simple mechanism for reporting +* success / failure of long running background operations. +* +* A object on which the operation is to be performed could have +* a public API which accepts a task callback: +* +* <example> +* <title>Task callback function signature</title> +* <programlisting> +* void myobject_operation(QMyObject *obj, +* QIOTaskFunc *func, +* gpointer opaque, +* GDestroyNotify *notify); +* </programlisting> +* </example> +* +* The 'func' parameter is the callback to be invoked, and 'opaque' +* is data to pass to it. The optional 'notify' function is used +* to free 'opaque' when no longer needed. +* +* Now, lets say the implementation of this method wants to set +* a timer to run once a second checking for completion of some +* activity. It would do something like +* +* <example> +* <title>Task callback function implementation</title> +* <programlisting> +* void myobject_operation(QMyObject *obj, +* QIOTaskFunc *func, +* gpointer opaque, +* GDestroyNotify *notify) +* { +* QIOTask *task; +* +* task = qio_task_new(OBJECT(obj), func, opaque, notify); +* +* g_timeout_add_full(G_PRIORITY_DEFAULT, +* 1000, +* myobject_operation_timer, +* task, +* NULL); +* } +* </programlisting> +* </example> +* +* It could equally have setup a watch on a file descriptor or +* created a background thread, or something else entirely. +* Notice that the source object is passed to the task, and +* QIOTask will hold a reference on that. This ensure that +* the QMyObject instance cannot be garbage collected while +* the async task is still in progress. +* +* In this case, myobject_operation_timer will fire after +* 3 secs and do +* +* <example> +* <title>Task timer function</title> +* <programlisting> +* gboolean myobject_operation_timer(gpointer opaque) +* { +* QIOTask *task = QIO_TASK(opaque); +* Error *err;* +* +* ...check something important... +* if (err) { +* qio_task_abort(task, err); +* error_free(task); +* return FALSE; +* } else if (...work is completed ...) { +* qio_task_complete(task); +* return FALSE; +* } +* ...carry on polling ... +* return TRUE; +* } +* </programlisting> +* </example> +* +* Once this function returns false, object_unref will be called +* automatically on the task causing it to be released and the +* ref on QMyObject dropped too. +* +* The QIOTask module can also be used to perform operations +* in a background thread context, while still reporting the +* results in the main event thread. This allows code which +* cannot easily be rewritten to be asychronous (such as DNS +* lookups) to be easily run non-blocking. Reporting the +* results in the main thread context means that the caller +* typically does not need to be concerned about thread +* safety wrt the QEMU global mutex. +* +* For example, the socket_listen() method will block the caller +* while DNS lookups take place if given a name, instead of IP +* address. The C library often do not provide a practical async +* DNS API, so the to get non-blocking DNS lookups in a portable +* manner requires use of a thread. So achieve a non-blocking +* socket listen using QIOTask would require: +* +* <example> +* static int myobject_listen_worker(QIOTask *task, +* Error **errp, +* gpointer opaque) +* { +* QMyObject obj = QMY_OBJECT(qio_task_get_source(task)); +* SocketAddress *addr = opaque; +* +* obj->fd = socket_listen(addr, errp); +* if (obj->fd < 0) { +* return -1; +* } +* return 0; +* } +* +* void myobject_listen_async(QMyObject *obj, +* SocketAddress *addr, +* QIOTaskFunc *func, +* gpointer opaque, +* GDestroyNotify *notify) +* { +* QIOTask *task; +* SocketAddress *addrCopy; +* +* qapi_copy_SocketAddress(&addrCopy, addr); +* task = qio_task_new(OBJECT(obj), func, opaque, notify); +* +* qio_task_run_in_thread(task, myobject_listen_worker, +* addrCopy, +* qapi_free_SocketAddress); +* } +* </example> +* +* NB, The 'func' callback passed into myobject_listen_async +* will be invoked from the main event thread, despite the +* actual operation being performed in a different thread. +*/ + +/** +* qio_task_new: +* @source: the object on which the operation is invoked +* @func: the callback to invoke when the task completes +* @opaque: opaque data to pass to @func when invoked +* @destroy: optional callback to free @opaque +* +* Creates a new task struct to track completion of a +* background operation running on the object @source. +* When the operation completes or fails, the callback +* @func will be invoked. The callback can access the +* 'err' attribute in the task object to determine if +* the operation was successful or not. +* +* The returned task will be released when one of +* qio_task_abort() or qio_task_complete() are invoked. +* +* Returns: the task struct +*/ +QIOTask *qio_task_new (Object *source, +QIOTaskFunc func, +gpointer opaque, +GDestroyNotify destroy); + +/** +* qio_task_run_in_thread: +* @task: the task struct +* @worker: the function to invoke in a thread +* @opaque: opaque data to pass to @worker +* @destroy: function to free @opaque +* +* Run a task in a background thread. If @worker +* returns 0 it will call qio_task_complete() in +* the main event thread context. If @worker +* returns -1 it will call qio_task_abort() in +* the main event thread context. +*/ +void qio_task_run_in_thread (QIOTask *task, +QIOTaskWorker worker, +gpointer opaque, +GDestroyNotify destroy); + +/** +* qio_task_complete: +* @task: the task struct +* +* Mark the operation as succesfully completed +* and free the memory for @task. +*/ +void qio_task_complete (QIOTask *task); + +/** +* qio_task_abort: +* @task: the task struct +* @err: the error to record for the operation +* +* Mark the operation as failed, with @err providing +* details about the failure. The @err may be freed +* afer the function returns, as the notification +* callback is invoked synchronously. The @task will +* be freed when this call completes. +*/ +void qio_task_abort (QIOTask *task, +Error *err); + + +/** +* qio_task_get_source: +* @task: the task struct +* +* Get the source object associated with the background +* task. This returns a new reference to the object, +* which the caller must released with object_unref() +* when no longer required. +* +* Returns: the source object +*/ +Object *qio_task_get_source (QIOTask *task); + +#endif /* QIO_TASK_H__ */
io/Makefile.objs +1 -0
@@ -1,3 +1,4 @@ io-obj-y = buffer.o +io-obj-y += task.o io-obj-y += channel.o io-obj-y += channel-watch.o
io/task.c new file +150 -0
150 lines not on this page · raw message
tests/.gitignore +1 -0
@@ -23,6 +23,7 @@ test-cutils test-hbitmap test-int128 test-iov +test-io-task test-mul64 test-opts-visitor test-qapi-event.[ch]
tests/Makefile +3 -0
@@ -78,6 +78,7 @@ check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF) check-unit-y += tests/test-crypto-cipher$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlscredsx509$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlssession$(EXESUF) +check-unit-y += tests/test-io-task$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -285,6 +286,7 @@ test-qapi-obj-y = tests/test-qapi-visit.o tests/test-qapi-types.o \ $(test-qom-obj-y) test-crypto-obj-y = $(crypto-obj-y) $(test-qom-obj-y) test-block-obj-y = $(block-obj-y) $(test-crypto-obj-y) +test-io-obj-y = $(io-obj-y) $(test-crypto-obj-y) tests/check-qint$(EXESUF): tests/check-qint.o $(test-util-obj-y) tests/check-qstring$(EXESUF): tests/check-qstring.o $(test-util-obj-y)
@@ -357,6 +359,7 @@ tests/test-crypto-tlscredsx509$(EXESUF): tests/test-crypto-tlscredsx509.o \ tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o $(test-crypto-obj-y) tests/test-crypto-tlssession$(EXESUF): tests/test-crypto-tlssession.o \ tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o $(test-crypto-obj-y) +tests/test-io-task$(EXESUF): tests/test-io-task.o $(test-io-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
tests/test-io-task.c new file +276 -0
276 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 10/46 io: add QIOChannelSocket class
In reply to Daniel P. BerrangeImplement a QIOChannel subclass that supports sockets I/O. The implementation is able to manage a single socket file descriptor, whether a TCP/UNIX listener, TCP/UNIX connection, or a UDP datagram. It provides APIs which can listen and connect either asynchronously or synchronously. Since there is no asynchronous DNS lookup API available, it uses the QIOTask helper for spawning a background thread to ensure non-blocking operation.
--- configure | 11 + include/io/channel-socket.h | 297 +++++++++++++++++ io/Makefile.objs | 1 + io/channel-socket.c | 718 +++++++++++++++++++++++++++++++++++++++++ scripts/create_config | 9 + tests/.gitignore | 1 + tests/Makefile | 3 + tests/io-channel-helpers.c | 222 +++++++++++++ tests/io-channel-helpers.h | 30 ++ tests/test-io-channel-socket.c | 349 ++++++++++++++++++++ 10 files changed, 1641 insertions(+) create mode 100644 include/io/channel-socket.h create mode 100644 io/channel-socket.c create mode 100644 tests/io-channel-helpers.c create mode 100644 tests/io-channel-helpers.h create mode 100644 tests/test-io-channel-socket.c
configure +11 -0
@@ -2259,6 +2259,14 @@ fi ########################################## +# getifaddrs (for tests/test-io-channel-socket ) + +have_ifaddrs_h=yes +if ! check_include "ifaddrs.h" ; then + have_ifaddrs_h=no +fi + +########################################## # VTE probe if test "$vte" != "no"; then
@@ -4901,6 +4909,9 @@ fi if test "$tasn1" = "yes" ; then echo "CONFIG_TASN1=y" >> $config_host_mak fi +if test "$have_ifaddrs_h" = "yes" ; then + echo "HAVE_IFADDRS_H=y" >> $config_host_mak +fi if test "$vte" = "yes" ; then echo "CONFIG_VTE=y" >> $config_host_mak echo "VTE_CFLAGS=$vte_cflags" >> $config_host_mak
include/io/channel-socket.h new file +297 -0
297 lines not on this page · raw message
io/Makefile.objs +1 -0
@@ -2,3 +2,4 @@ io-obj-y = buffer.o io-obj-y += task.o io-obj-y += channel.o io-obj-y += channel-watch.o +io-obj-y += channel-socket.o
io/channel-socket.c new file +718 -0
718 lines not on this page · raw message
scripts/create_config +9 -0
@@ -61,6 +61,15 @@ case $line in value=${line#*=} echo "#define $name $value" ;; + HAVE_*=y) # configuration + name=${line%=*} + echo "#define $name 1" + ;; + HAVE_*=*) # configuration + name=${line%=*} + value=${line#*=} + echo "#define $name $value" + ;; ARCH=*) # configuration arch=${line#*=} arch_name=`echo $arch | LC_ALL=C tr '[a-z]' '[A-Z]'`
tests/.gitignore +1 -0
@@ -23,6 +23,7 @@ test-cutils test-hbitmap test-int128 test-iov +test-io-channel-socket test-io-task test-mul64 test-opts-visitor
tests/Makefile +3 -0
@@ -79,6 +79,7 @@ check-unit-y += tests/test-crypto-cipher$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlscredsx509$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlssession$(EXESUF) check-unit-y += tests/test-io-task$(EXESUF) +check-unit-y += tests/test-io-channel-socket$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -360,6 +361,8 @@ tests/test-crypto-tlscredsx509$(EXESUF): tests/test-crypto-tlscredsx509.o \ tests/test-crypto-tlssession$(EXESUF): tests/test-crypto-tlssession.o \ tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o $(test-crypto-obj-y) tests/test-io-task$(EXESUF): tests/test-io-task.o $(test-io-obj-y) +tests/test-io-channel-socket$(EXESUF): tests/test-io-channel-socket.o \ + tests/io-channel-helpers.o $(test-io-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
tests/io-channel-helpers.c new file +222 -0
222 lines not on this page · raw message
tests/io-channel-helpers.h new file +30 -0
@@ -0,0 +1,30 @@ +/* +* QEMU I/O channel test helpers +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#include "io/channel.h" + +#ifndef TEST_IO_CHANNEL_HELPERS +#define TEST_IO_CHANNEL_HELPERS + +void test_io_channel_comms (bool blocking, +QIOChannel *src, +QIOChannel *dst); + +#endif /* TEST_IO_CHANNEL_HELPERS */
tests/test-io-channel-socket.c new file +349 -0
349 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 11/46 io: add QIOChannelFile class
In reply to Daniel P. BerrangeAdd a QIOChannel subclass that is capable of operating on things that are files, such as plain files, pipes, character/block devices, but notably not sockets.
--- include/io/channel-file.h | 93 +++++++++++++++++++ io/Makefile.objs | 1 + io/channel-file.c | 209 +++++++++++++++++++++++++++++++++++++++++++ tests/.gitignore | 2 + tests/Makefile | 3 + tests/io-channel-helpers.c | 25 ++++++ tests/io-channel-helpers.h | 3 + tests/test-io-channel-file.c | 89 ++++++++++++++++++ 8 files changed, 425 insertions(+) create mode 100644 include/io/channel-file.h create mode 100644 io/channel-file.c create mode 100644 tests/test-io-channel-file.c
include/io/channel-file.h new file +93 -0
@@ -0,0 +1,93 @@ +/* +* QEMU I/O channels files driver +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QIO_CHANNEL_FILE_H__ +#define QIO_CHANNEL_FILE_H__ + +#include "io/channel.h" + +#define TYPE_QIO_CHANNEL_FILE "qio-channel-file" +#define QIO_CHANNEL_FILE (obj) \ + OBJECT_CHECK(QIOChannelFile, (obj), TYPE_QIO_CHANNEL_FILE) + +typedef struct QIOChannelFile QIOChannelFile ; + +/** +* QIOChannelFile: +* +* The QIOChannelFile object provides a channel implementation +* that is able to perform I/O on block devices, character +* devices, FIFOs, pipes and plain files. While it is technically +* able to work on sockets too on the UNIX platform, this is not +* portable to Windows and lacks some extra sockets specific +* functionality. So the QIOChannelSocket object is recommended +* for that use case. +* +*/ + +struct QIOChannelFile { +QIOChannel parent; +int fd; +}; + + +/** +* qio_channel_file_new_fd: +* @fd: the file descriptor +* +* Create a new IO channel object for a file represented +* by the @fd parameter. @fd can be associated with a +* block device, character device, fifo, pipe, or a +* regular file. For sockets, the QIOChannelSocket class +* should be used instead, as this provides greater +* functionality and cross platform portability. +* +* The channel will own the passed in file descriptor +* and will take responsibility for closing it, so the +* caller must not close it. If appropriate the caller +* should dup() its FD before opening the channel. +* +* Returns: the new channel object +*/ +QIOChannelFile * +qio_channel_file_new_fd (int fd); + +/** +* qio_channel_file_new_path: +* @fd: the file descriptor +* @flags: the open flags (O_RDONLY|O_WRONLY|O_RDWR, etc) +* @mode: the file creation mode if O_WRONLY is set in @flags +* @errp: pointer to initialized error object +* +* Create a new IO channel object for a file represented +* by the @path parameter. @path can point to any +* type of file on which sequential I/O can be +* performed, whether it be a plain file, character +* device or block device. +* +* Returns: the new channel object +*/ +QIOChannelFile * +qio_channel_file_new_path (const char *path, +int flags, +mode_t mode, +Error **errp); + +#endif /* QIO_CHANNEL_FILE_H__ */
io/Makefile.objs +1 -0
@@ -3,3 +3,4 @@ io-obj-y += task.o io-obj-y += channel.o io-obj-y += channel-watch.o io-obj-y += channel-socket.o +io-obj-y += channel-file.o
io/channel-file.c new file +209 -0
209 lines not on this page · raw message
tests/.gitignore +2 -0
@@ -23,6 +23,8 @@ test-cutils test-hbitmap test-int128 test-iov +test-io-channel-file +test-io-channel-file.txt test-io-channel-socket test-io-task test-mul64
tests/Makefile +3 -0
@@ -80,6 +80,7 @@ check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlscredsx509$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlssession$(EXESUF) check-unit-y += tests/test-io-task$(EXESUF) check-unit-y += tests/test-io-channel-socket$(EXESUF) +check-unit-y += tests/test-io-channel-file$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -363,6 +364,8 @@ tests/test-crypto-tlssession$(EXESUF): tests/test-crypto-tlssession.o \ tests/test-io-task$(EXESUF): tests/test-io-task.o $(test-io-obj-y) tests/test-io-channel-socket$(EXESUF): tests/test-io-channel-socket.o \ tests/io-channel-helpers.o $(test-io-obj-y) +tests/test-io-channel-file$(EXESUF): tests/test-io-channel-file.o \ + tests/io-channel-helpers.o $(test-io-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
tests/io-channel-helpers.c +25 -0
@@ -220,3 +220,28 @@ void test_io_channel_comms(bool blocking,g_free (data->output);g_free (data); } + + +void test_io_channel_comms_serial (QIOChannel *src, +QIOChannel *dst) +{ +struct TestIOData *data; + + data =test_load_io_data ("libqemuutil.a" ); + data->src = src; + data->dst = dst; + data->blocking = true; + +test_io_thread_writer (data); +test_io_thread_reader (data); + +g_assert_cmpint (memcmp (data->input, + data->output, + data->len), ==, 0); +g_assert (data->readerr ==NULL ); +g_assert (data->writeerr ==NULL ); + +g_free (data->input); +g_free (data->output); +g_free (data); +}
tests/io-channel-helpers.h +3 -0
@@ -27,4 +27,7 @@ void test_io_channel_comms(bool blocking, QIOChannel *src, QIOChannel *dst); +void test_io_channel_comms_serial (QIOChannel *src, +QIOChannel *dst); +#endif /* TEST_IO_CHANNEL_HELPERS */
tests/test-io-channel-file.c new file +89 -0
89 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 12/46 io: add QIOChannelTLS class
In reply to Daniel P. BerrangeAdd a QIOChannel subclass that can run the TLS protocol over the top of another QIOChannel instance. The object provides a simplified API to perform the handshake when starting the TLS session. The layering of TLS over the underlying channel does not have to be setup immediately. It is possible to take an existing QIOChannel that has done some handshake and then swap in the QIOChannelTLS layer. This allows for use with protocols which start TLS right away, and those which start plain text and then negotiate TLS.
--- include/io/channel-tls.h | 142 +++++++++++++++++ io/Makefile.objs | 1 + io/channel-tls.c | 381 ++++++++++++++++++++++++++++++++++++++++++++ tests/.gitignore | 1 + tests/Makefile | 4 + tests/test-io-channel-tls.c | 335 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 864 insertions(+) create mode 100644 include/io/channel-tls.h create mode 100644 io/channel-tls.c create mode 100644 tests/test-io-channel-tls.c
include/io/channel-tls.h new file +142 -0
@@ -0,0 +1,142 @@ +/* +* QEMU I/O channels TLS driver +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QIO_CHANNEL_TLS_H__ +#define QIO_CHANNEL_TLS_H__ + +#include "io/channel.h" +#include "io/task.h" +#include "crypto/tlssession.h" + +#define TYPE_QIO_CHANNEL_TLS "qio-channel-tls" +#define QIO_CHANNEL_TLS (obj) \ + OBJECT_CHECK(QIOChannelTLS, (obj), TYPE_QIO_CHANNEL_TLS) + +typedef struct QIOChannelTLS QIOChannelTLS ; + +/** +* QIOChannelTLS +* +* The QIOChannelTLS class provides a channel wrapper which +* can transparently run the TLS encryption protocol. It is +* usually used over a TCP socket, but there is actually no +* technical restriction on which type of master channel is +* used as the transport. +* +* This channel object is capable of running as either a +* TLS server or TLS client. +*/ + +struct QIOChannelTLS { +QIOChannel parent; +QIOChannel *master; +QCryptoTLSSession *session; +}; + +/** +* qio_channel_tls_new_server: +* @master: the underlying channel object +* @creds: the credentials to use for TLS handshake +* @aclname: the access control list for validating clients +* @errp: pointer to an uninitialized error object +* +* Create a new TLS channel that runs the server side of +* a TLS session. The TLS session handshake will use the +* credentials provided in @creds. If the @aclname parameter +* is non-NULL, then the client will have to provide +* credentials (ie a x509 client certificate) which will +* then be validated against the ACL. +* +* After creating the channel, it is mandatory to call +* the qio_channel_tls_handshake() method before attempting +* todo any I/O on the channel. +* +* Once the handshake has completed, all I/O should be done +* via the new TLS channel object and not the original +* master channel +* +* Returns: the new TLS channel object, or NULL +*/ +QIOChannelTLS * +qio_channel_tls_new_server (QIOChannel *master, +QCryptoTLSCreds *creds, +const char *aclname, +Error **errp); + +/** +* qio_channel_tls_new_client: +* @master: the underlying channel object +* @creds: the credentials to use for TLS handshake +* @hostname: the user specified server hostname +* @errp: pointer to an uninitialized error object +* +* Create a new TLS channel that runs the client side of +* a TLS session. The TLS session handshake will use the +* credentials provided in @creds. The @hostname parameter +* should provide the user specified hostname of the server +* and will be validated against the server's credentials +* (ie CommonName of the x509 certificate) +* +* After creating the channel, it is mandatory to call +* the qio_channel_tls_handshake() method before attempting +* todo any I/O on the channel. +* +* Once the handshake has completed, all I/O should be done +* via the new TLS channel object and not the original +* master channel +* +* Returns: the new TLS channel object, or NULL +*/ +QIOChannelTLS * +qio_channel_tls_new_client (QIOChannel *master, +QCryptoTLSCreds *creds, +const char *hostname, +Error **errp); + +/** +* qio_channel_tls_handshake: +* @ioc: the TLS channel object +* @func: the callback to invoke when completed +* @opaque: opaque data to pass to @func +* @destroy: optional callback to free @opaque +* +* Perform the TLS session handshake. This method +* will return immediately and the handshake will +* continue in the background, provided the main +* loop is running. When the handshake is complete, +* or fails, the @func callback will be invoked. +*/ +void qio_channel_tls_handshake (QIOChannelTLS *ioc, +QIOTaskFunc func, +gpointer opaque, +GDestroyNotify destroy); + +/** +* qio_channel_tls_get_session: +* @ioc: the TLS channel object +* +* Get the TLS session used by the channel. +* +* Returns: the TLS session +*/ +QCryptoTLSSession * +qio_channel_tls_get_session (QIOChannelTLS *ioc); + +#endif /* QIO_CHANNEL_TLS_H__ */
io/Makefile.objs +1 -0
@@ -4,3 +4,4 @@ io-obj-y += channel.o io-obj-y += channel-watch.o io-obj-y += channel-socket.o io-obj-y += channel-file.o +io-obj-y += channel-tls.o
io/channel-tls.c new file +381 -0
381 lines not on this page · raw message
tests/.gitignore +1 -0
@@ -26,6 +26,7 @@ test-iov test-io-channel-file test-io-channel-file.txt test-io-channel-socket +test-io-channel-tls test-io-task test-mul64 test-opts-visitor
tests/Makefile +4 -0
@@ -81,6 +81,7 @@ check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlssession$(EXESUF) check-unit-y += tests/test-io-task$(EXESUF) check-unit-y += tests/test-io-channel-socket$(EXESUF) check-unit-y += tests/test-io-channel-file$(EXESUF) +check-unit-$(CONFIG_GNUTLS) += tests/test-io-channel-tls$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -366,6 +367,9 @@ tests/test-io-channel-socket$(EXESUF): tests/test-io-channel-socket.o \ tests/io-channel-helpers.o $(test-io-obj-y) tests/test-io-channel-file$(EXESUF): tests/test-io-channel-file.o \ tests/io-channel-helpers.o $(test-io-obj-y) +tests/test-io-channel-tls$(EXESUF): tests/test-io-channel-tls.o \ + tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o \ + tests/io-channel-helpers.o $(test-io-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
tests/test-io-channel-tls.c new file +335 -0
335 lines not on this page · raw message
Signature · 1 line
2.4.3
Re: [Qemu-devel] [PATCH FYI 12/46] io: add QIOChannelTLS class
Quoted 13 lines · * Daniel P. Berrange ([email protected]) wrote:
Add a QIOChannel subclass that can run the TLS protocol over the top of another QIOChannel instance. The object provides a simplified API to perform the handshake when starting the TLS session. The layering of TLS over the underlying channel does not have to be setup immediately. It is possible to take an existing QIOChannel that has done some handshake and then swap in the QIOChannelTLS layer. This allows for use with protocols which start TLS right away, and those which start plain text and then negotiate TLS.
Signed-off-by Daniel P. Berrange <[email protected]>---
io/channel-tls.c line 31
Quoted 5 lines
io/channel-tls.c new file +5
-0+#ifdef QIO_DEBUG +#define DPRINTF (fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) +#else +#define DPRINTF (fmt, ...) do { } while (0) +#endif
Can you use the trace_ stuff rather than dprintf's; I've been trying to remove them all from the migration code (and with trace configured in stderr mode it works pretty easily).
On a different question; if this TLS channel is backed by a socket, can I do a shutdown call that will bubble down to the socket?
Dave
Quoted 728 lines
io/channel-tls.c new file +350
-0+ + +static ssize_t qio_channel_tls_write_handler (const char *buf, +size_t len, +void *opaque) +{ +QIOChannelTLS *tioc =QIO_CHANNEL_TLS (opaque); +ssize_t ret; + + ret =qio_channel_write (tioc->master, buf, len,NULL ); +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { + errno =EAGAIN ; +return -1 ; + }else if (ret <0 ) { + errno =EIO ; +return -1 ; + } +return ret; +} + +static ssize_t qio_channel_tls_read_handler (char *buf, +size_t len, +void *opaque) +{ +QIOChannelTLS *tioc =QIO_CHANNEL_TLS (opaque); +ssize_t ret; + + ret =qio_channel_read (tioc->master, buf, len,NULL ); +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { + errno =EAGAIN ; +return -1 ; + }else if (ret <0 ) { + errno =EIO ; +return -1 ; + } +return ret; +} + + +QIOChannelTLS * +qio_channel_tls_new_server (QIOChannel *master, +QCryptoTLSCreds *creds, +const char *aclname, +Error **errp) +{ +QIOChannelTLS *ioc; + + ioc =QIO_CHANNEL_TLS (object_new (TYPE_QIO_CHANNEL_TLS )); + + ioc->master = master; +object_ref (OBJECT (master)); + + ioc->session =qcrypto_tls_session_new ( + creds, +NULL , + aclname, +QCRYPTO_TLS_CREDS_ENDPOINT_SERVER , + errp); +if (!ioc->session) { + goto error; + } + +qcrypto_tls_session_set_callbacks ( + ioc->session, + qio_channel_tls_write_handler, + qio_channel_tls_read_handler, + ioc); + +return ioc; + + error: +DPRINTF ("Session setup failed %s\n" , +error_get_pretty (*errp)); +object_unref (OBJECT (ioc)); +return NULL ; +} + +QIOChannelTLS * +qio_channel_tls_new_client (QIOChannel *master, +QCryptoTLSCreds *creds, +const char *hostname, +Error **errp) +{ +QIOChannelTLS *ioc; + + ioc =QIO_CHANNEL_TLS (object_new (TYPE_QIO_CHANNEL_TLS )); + + ioc->master = master; +object_ref (OBJECT (master)); + + ioc->session =qcrypto_tls_session_new ( + creds, + hostname, +NULL , +QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT , + errp); +if (!ioc->session) { + goto error; + } + +qcrypto_tls_session_set_callbacks ( + ioc->session, + qio_channel_tls_write_handler, + qio_channel_tls_read_handler, + ioc); + +return ioc; + + error: +DPRINTF ("Session setup failed %s\n" , +error_get_pretty (*errp)); +object_unref (OBJECT (ioc)); +return NULL ; +} + + +static gboolean qio_channel_tls_handshake_io (QIOChannel *ioc, +GIOCondition condition, +gpointer user_data); + +static void qio_channel_tls_handshake_task (QIOChannelTLS *ioc, +QIOTask *task) +{ +Error *err =NULL ; +QCryptoTLSSessionHandshakeStatus status; + +if (qcrypto_tls_session_handshake (ioc->session, &err) <0 ) { +qio_task_abort (task, err); + goto cleanup; + } + + status =qcrypto_tls_session_get_handshake_status (ioc->session); +if (status ==QCRYPTO_TLS_HANDSHAKE_COMPLETE ) { +if (qcrypto_tls_session_check_credentials (ioc->session, + &err) <0 ) { +DPRINTF ("Check creds failed session=%p err=%s\n" , + ioc->session,error_get_pretty (err)); +qio_task_abort (task, err); + goto cleanup; + } +DPRINTF ("Handshake compelte session=%p\n" , + ioc->session); +qio_task_complete (task); + }else { +GIOCondition condition; +DPRINTF ("Handshake still running %d\n" , status); +if (status ==QCRYPTO_TLS_HANDSHAKE_SENDING ) { + condition =G_IO_OUT ; + }else { + condition =G_IO_IN ; + } + +qio_channel_add_watch (ioc->master, + condition, + qio_channel_tls_handshake_io, + task, +NULL ); + } + + cleanup: +error_free (err); +} + + +static gboolean qio_channel_tls_handshake_io (QIOChannel *ioc, +GIOCondition condition, +gpointer user_data) +{ +QIOTask *task = user_data; +QIOChannelTLS *tioc =QIO_CHANNEL_TLS ( +qio_task_get_source (task)); + +qio_channel_tls_handshake_task ( + tioc, task); + +object_unref (OBJECT (tioc)); + +return FALSE; +} + +void qio_channel_tls_handshake (QIOChannelTLS *ioc, +QIOTaskFunc func, +gpointer opaque, +GDestroyNotify destroy) +{ +QIOTask *task; + + task =qio_task_new (OBJECT (ioc), + func, opaque, destroy); + +qio_channel_tls_handshake_task (ioc, task); +} + + +static void qio_channel_tls_init(Object *obj G_GNUC_UNUSED) +{ +} + + +static void qio_channel_tls_finalize (Object *obj) +{ +QIOChannelTLS *ioc =QIO_CHANNEL_TLS (obj); + +object_unref (OBJECT (ioc->master)); +qcrypto_tls_session_free (ioc->session); +} + + +static ssize_t qio_channel_tls_readv (QIOChannel *ioc, +const struct iovec *iov, +size_t niov, +int **fds, +size_t *nfds, +Error **errp) +{ +QIOChannelTLS *tioc =QIO_CHANNEL_TLS (ioc); +size_t i; +ssize_t got =0 ; + +if (fds || nfds) { +error_setg (errp,"%s" , +_ ("Cannot receive file descriptors over TLS channel" )); +return -1 ; + } + +for (i =0 ; i < niov ; i++) { +ssize_t ret =qcrypto_tls_session_read (tioc->session, + iov[i].iov_base, + iov[i].iov_len); +if (ret <0 ) { +if (errno ==EAGAIN ) { +if (got) { +return got; + }else { +return QIO_CHANNEL_ERR_BLOCK ; + } + } + +error_setg_errno (errp, errno,"%s" , +_ ("Cannot read from TLS channel" )); +return -1 ; + } + got += ret; +if (ret < iov[i].iov_len) { +break ; + } + } +return got; +} + + +static ssize_t qio_channel_tls_writev (QIOChannel *ioc, +const struct iovec *iov, +size_t niov, +int *fds, +size_t nfds, +Error **errp) +{ +QIOChannelTLS *tioc =QIO_CHANNEL_TLS (ioc); +size_t i; +ssize_t done =0 ; + +if (fds || nfds) { +error_setg (errp,"%s" , +_ ("Cannot send file descriptors over TLS channel" )); +return -1 ; + } + +for (i =0 ; i < niov ; i++) { +ssize_t ret =qcrypto_tls_session_write (tioc->session, + iov[i].iov_base, + iov[i].iov_len); +if (ret <=0 ) { +if (errno ==EAGAIN ) { +if (done) { +return done; + }else { +return QIO_CHANNEL_ERR_BLOCK ; + } + } + +error_setg_errno (errp, errno,"%s" , +_ ("Cannot write to TLS channel" )); +return -1 ; + } + done += ret; +if (ret < iov[i].iov_len) { +break ; + } + } +return done; +} + +static void qio_channel_tls_set_blocking (QIOChannel *ioc, +bool enabled) +{ +QIOChannelTLS *tioc =QIO_CHANNEL_TLS (ioc); + +qio_channel_set_blocking (tioc->master, enabled); +} + +static int qio_channel_tls_close (QIOChannel *ioc, +Error **errp) +{ +QIOChannelTLS *tioc =QIO_CHANNEL_TLS (ioc); + +return qio_channel_close (tioc->master, errp); +} + +static GSource *qio_channel_tls_create_watch (QIOChannel *ioc, +GIOCondition condition) +{ +QIOChannelTLS *tioc =QIO_CHANNEL_TLS (ioc); + +return qio_channel_create_watch (tioc->master, condition); +} + +QCryptoTLSSession * +qio_channel_tls_get_session (QIOChannelTLS *ioc) +{ +return ioc->session; +} + +static void qio_channel_tls_class_init (ObjectClass *klass, + void *class_data G_GNUC_UNUSED) +{ +QIOChannelClass *ioc_klass =QIO_CHANNEL_CLASS (klass); + + ioc_klass->io_writev = qio_channel_tls_writev; + ioc_klass->io_readv = qio_channel_tls_readv; + ioc_klass->io_set_blocking = qio_channel_tls_set_blocking; + ioc_klass->io_close = qio_channel_tls_close; + ioc_klass->io_create_watch = qio_channel_tls_create_watch; +} + +static const TypeInfo qio_channel_tls_info = { + .parent =TYPE_QIO_CHANNEL , + .name =TYPE_QIO_CHANNEL_TLS , + .instance_size =sizeof (QIOChannelTLS), + .instance_init = qio_channel_tls_init, + .instance_finalize = qio_channel_tls_finalize, + .class_init = qio_channel_tls_class_init, +}; + +static void qio_channel_tls_register_types (void ) +{ +type_register_static (&qio_channel_tls_info); +} + +type_init (qio_channel_tls_register_types);tests/.gitignore +1
-0@@ -26,6 +26,7 @@ test-iov test-io-channel-file test-io-channel-file.txt test-io-channel-socket +test-io-channel-tls test-io-task test-mul64 test-opts-visitortests/Makefile +4
-0@@ -81,6 +81,7 @@ check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlssession$(EXESUF) check-unit-y += tests/test-io-task$(EXESUF) check-unit-y += tests/test-io-channel-socket$(EXESUF) check-unit-y += tests/test-io-channel-file$(EXESUF) +check-unit-$(CONFIG_GNUTLS) += tests/test-io-channel-tls$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh@@ -366,6 +367,9 @@ tests/test-io-channel-socket$(EXESUF): tests/test-io-channel-socket.o \ tests/io-channel-helpers.o $(test-io-obj-y) tests/test-io-channel-file$(EXESUF): tests/test-io-channel-file.o \ tests/io-channel-helpers.o $(test-io-obj-y) +tests/test-io-channel-tls$(EXESUF): tests/test-io-channel-tls.o \ + tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o \ + tests/io-channel-helpers.o $(test-io-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.otests/test-io-channel-tls.c new file +335
-0@@ -0,0 +1,335 @@ +/* +* Copyright (C) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2.1 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library. If not, see +* <http://www.gnu.org/licenses/>. +* +* Author: Daniel P. Berrange <[email protected]> +*/ + + +#include <stdlib.h> +#include <fcntl.h> + +#include "config-host.h" +#include "crypto-tls-x509-helpers.h" +#include "io/channel-tls.h" +#include "io/channel-socket.h" +#include "io-channel-helpers.h" +#include "crypto/tlscredsx509.h" +#include "qemu/acl.h" +#include "qom/object_interfaces.h" + +#ifdef QCRYPTO_HAVE_TLS_TEST_SUPPORT + +#define WORKDIR "tests/test-io-channel-tls-work/" +#define KEYFILE WORKDIR "key-ctx.pem" + +struct QIOChannelTLSTestData { +const char *servercacrt; +const char *clientcacrt; +const char *servercrt; +const char *clientcrt; +bool expectServerFail; +bool expectClientFail; +const char *hostname; +const char *const *wildcards; +}; + +struct QIOChannelTLSHandshakeData { +bool finished; +bool failed; +}; + +static void test_tls_handshake_done (Object *source, +Error *err, +gpointer opaque) +{ +struct QIOChannelTLSHandshakeData *data = opaque; + + data->finished = true; + data->failed = err !=NULL ; +} + + +static QCryptoTLSCreds *test_tls_creds_create (QCryptoTLSCredsEndpoint endpoint, +const char *certdir, +Error **errp) +{ +Object *parent =object_get_objects_root (); +Object *creds =object_new_with_props ( +TYPE_QCRYPTO_TLS_CREDS_X509 , + parent, + (endpoint ==QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ? +"testtlscredsserver" :"testtlscredsclient" ), + errp, +"endpoint" , (endpoint ==QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ? +"server" :"client" ), +"dir" , certdir, +"verify-peer" ,"yes" , +/* We skip initial sanity checks here because we +* want to make sure that problems are being +* detected at the TLS session validation stage, +* and the test-crypto-tlscreds test already +* validate the sanity check code. +*/ +"sanity-check" ,"no" , +NULL + ); + +if (*errp) { +return NULL ; + } +return QCRYPTO_TLS_CREDS (creds); +} + + +/* +* This tests validation checking of peer certificates +* +* This is replicating the checks that are done for an +* active TLS session after handshake completes. To +* simulate that we create our TLS contexts, skipping +* sanity checks. When then get a socketpair, and +* initiate a TLS session across them. Finally do +* do actual cert validation tests +*/ +static void test_io_channel_tls (const void *opaque) +{ +struct QIOChannelTLSTestData *data = + (struct QIOChannelTLSTestData *)opaque; +QCryptoTLSCreds *clientCreds; +QCryptoTLSCreds *serverCreds; +QIOChannelTLS *clientChanTLS; +QIOChannelTLS *serverChanTLS; +QIOChannelSocket *clientChanSock; +QIOChannelSocket *serverChanSock; +qemu_acl *acl; +const char *const *wildcards; +int channel[2 ]; +struct QIOChannelTLSHandshakeData clientHandshake = { false, false }; +struct QIOChannelTLSHandshakeData serverHandshake = { false, false }; +Error *err =NULL ; +GMainContext *mainloop; + +/* We'll use this for our fake client-server connection */ +g_assert (socketpair (AF_UNIX ,SOCK_STREAM ,0 , channel) ==0 ); + +#define CLIENT_CERT_DIR "tests/test-crypto-tlssession-client/" +#define SERVER_CERT_DIR "tests/test-crypto-tlssession-server/" +mkdir (CLIENT_CERT_DIR ,0700 ); +mkdir (SERVER_CERT_DIR ,0700 ); + + unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT); + unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT); + unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY); + + unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT); + unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT); + unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY); + +g_assert (link (data->servercacrt, + SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT) == 0); +g_assert (link (data->servercrt, + SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT) == 0); +g_assert (link (KEYFILE , + SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY) == 0); + +g_assert (link (data->clientcacrt, + CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT) == 0); +g_assert (link (data->clientcrt, + CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT) == 0); +g_assert (link (KEYFILE , + CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY) == 0); + + clientCreds =test_tls_creds_create ( +QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT , +CLIENT_CERT_DIR , + &err); +g_assert (clientCreds !=NULL ); + + serverCreds =test_tls_creds_create ( +QCRYPTO_TLS_CREDS_ENDPOINT_SERVER , +SERVER_CERT_DIR , + &err); +g_assert (serverCreds !=NULL ); + + acl =qemu_acl_init ("channeltlsacl" ); +qemu_acl_reset (acl); + wildcards = data->wildcards; +while (wildcards && *wildcards) { +qemu_acl_append (acl,0 , *wildcards); + wildcards++; + } + + clientChanSock =qio_channel_socket_new_fd ( + channel[0 ], &err); +g_assert (clientChanSock !=NULL ); + serverChanSock =qio_channel_socket_new_fd ( + channel[1 ], &err); +g_assert (serverChanSock !=NULL ); + +/* +* We have an evil loop to do the handshake in a single +* thread, so we need these non-blocking to avoid deadlock +* of ourselves +*/ +qio_channel_set_blocking (QIO_CHANNEL (clientChanSock), false); +qio_channel_set_blocking (QIO_CHANNEL (serverChanSock), false); + +/* Now the real part of the test, setup the sessions */ + clientChanTLS =qio_channel_tls_new_client ( +QIO_CHANNEL (clientChanSock), clientCreds, + data->hostname, &err); +g_assert (clientChanTLS !=NULL ); + + serverChanTLS =qio_channel_tls_new_server ( +QIO_CHANNEL (serverChanSock), serverCreds, +"channeltlsacl" , &err); +g_assert (serverChanTLS !=NULL ); + +qio_channel_tls_handshake (clientChanTLS, + test_tls_handshake_done, + &clientHandshake, +NULL ); +qio_channel_tls_handshake (serverChanTLS, + test_tls_handshake_done, + &serverHandshake, +NULL ); + +/* +* Finally we loop around & around doing handshake on each +* session until we get an error, or the handshake completes. +* This relies on the socketpair being nonblocking to avoid +* deadlocking ourselves upon handshake +*/ + mainloop =g_main_context_default (); +do { +g_main_context_iteration (mainloop, TRUE); + }while (!clientHandshake.finished && + !serverHandshake.finished); + +g_assert (clientHandshake.failed == data->expectClientFail); +g_assert (serverHandshake.failed == data->expectServerFail); + +test_io_channel_comms (false, +QIO_CHANNEL (clientChanTLS), +QIO_CHANNEL (serverChanTLS)); + +test_io_channel_comms (true, +QIO_CHANNEL (clientChanTLS), +QIO_CHANNEL (serverChanTLS)); + + unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT); + unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_CERT); + unlink(SERVER_CERT_DIR QCRYPTO_TLS_CREDS_X509_SERVER_KEY); + + unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CA_CERT); + unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_CERT); + unlink(CLIENT_CERT_DIR QCRYPTO_TLS_CREDS_X509_CLIENT_KEY); + +rmdir (CLIENT_CERT_DIR ); +rmdir (SERVER_CERT_DIR ); + +object_unparent (OBJECT (serverCreds)); +object_unparent (OBJECT (clientCreds)); + +object_unref (OBJECT (serverChanTLS)); +object_unref (OBJECT (clientChanTLS)); + +object_unref (OBJECT (serverChanSock)); +object_unref (OBJECT (clientChanSock)); + +close (channel[0 ]); +close (channel[1 ]); +} + + +int main (int argc,char **argv) +{ +int ret; + +module_call_init (MODULE_INIT_QOM ); +g_test_init (&argc, &argv,NULL ); +setenv ("GNUTLS_FORCE_FIPS_MODE" ,"2" ,1 ); + +mkdir (WORKDIR ,0700 ); + +test_tls_init (KEYFILE ); + +# define TEST_CHANNEL (name, caCrt, \ + serverCrt, clientCrt, \ + expectServerFail, expectClientFail, \ + hostname, wildcards) \ + struct QIOChannelTLSTestData name = { \ + caCrt, caCrt, serverCrt, clientCrt, \ + expectServerFail, expectClientFail, \ + hostname, wildcards \ + }; \ + g_test_add_data_func("/qio/channel/tls/" # name, \ + &name, test_io_channel_tls); + +/* A perfect CA, perfect client & perfect server */ + +/* Basic:CA:critical */ +TLS_ROOT_REQ (cacertreq, +"UK" ,"qemu CA" ,NULL ,NULL ,NULL ,NULL , + true, true, true, + true, true,GNUTLS_KEY_KEY_CERT_SIGN , + false, false,NULL ,NULL , +0 ,0 ); +TLS_CERT_REQ (servercertreq, cacertreq, +"UK" ,"qemu.org" ,NULL ,NULL ,NULL ,NULL , + true, true, false, + true, true, +GNUTLS_KEY_DIGITAL_SIGNATURE |GNUTLS_KEY_KEY_ENCIPHERMENT , + true, true,GNUTLS_KP_TLS_WWW_SERVER ,NULL , +0 ,0 ); +TLS_CERT_REQ (clientcertreq, cacertreq, +"UK" ,"qemu" ,NULL ,NULL ,NULL ,NULL , + true, true, false, + true, true, +GNUTLS_KEY_DIGITAL_SIGNATURE |GNUTLS_KEY_KEY_ENCIPHERMENT , + true, true,GNUTLS_KP_TLS_WWW_CLIENT ,NULL , +0 ,0 ); + +const char *const wildcards[] = { +"C=UK,CN=qemu*" , +NULL , + }; +TEST_CHANNEL (basic, cacertreq.filename, servercertreq.filename, + clientcertreq.filename, false, false, +"qemu.org" , wildcards); + + ret =g_test_run (); + +test_tls_discard_cert (&clientcertreq); +test_tls_discard_cert (&servercertreq); +test_tls_discard_cert (&cacertreq); + +test_tls_cleanup (KEYFILE ); +rmdir (WORKDIR ); + +return ret ==0 ?EXIT_SUCCESS :EXIT_FAILURE ; +} + +#else /* ! QCRYPTO_HAVE_TLS_TEST_SUPPORT */ + +int +main (void ) +{ +return EXIT_SUCCESS ; +} + +#endif /* ! QCRYPTO_HAVE_TLS_TEST_SUPPORT */ Signature · 1 line
2.4.3
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Re: [Qemu-devel] [PATCH FYI 12/46] io: add QIOChannelTLS class
Quoted 13 lines · Dr. David Alan Gilbert
Quoted 11 lines · * Daniel P. Berrange ([email protected]) wrote:
Add a QIOChannel subclass that can run the TLS protocol over the top of another QIOChannel instance. The object provides a simplified API to perform the handshake when starting the TLS session. The layering of TLS over the underlying channel does not have to be setup immediately. It is possible to take an existing QIOChannel that has done some handshake and then swap in the QIOChannelTLS layer. This allows for use with protocols which start TLS right away, and those which start plain text and then negotiate TLS.
Signed-off-by Daniel P. Berrange <[email protected]>
Quoted 10 lines
io/channel-tls.c line 31
Quoted 6 lines
---
io/channel-tls.c new file +5
-0+#ifdef QIO_DEBUG +#define DPRINTF (fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) +#else +#define DPRINTF (fmt, ...) do { } while (0) +#endif Can you use the
trace_stuff rather than dprintf's; I've been trying to remove them all from the migration code (and with trace configured in stderr mode it works pretty easily).
Yeah, that's a good idea.
Quoted 2 lines
On a different question; if this TLS channel is backed by a socket, can I do a shutdown call that will bubble down to the socket?
The QIOChannel abstract base class did not define any shutdown method, since that's not a generally applicable concept - essentially only the sockets interface can do that. So I defined it as a method just on the QIOChannelSocket class. Given this, the QIOChannelTLS class does not know about the shutdown call.
This isn't a big deal though - the QIOChannelTLS struct exposes a pointer to the underling QIOChannel transport, so code that needs to do a shutdown, can get hold of the underlying channel and call shutdown on that.
I forgot to do this properly when I integrated with the migration QEMUFile interface, so I'll fix that up, so shutdown works correctly with migration when TLS is enabled.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
Re: [Qemu-devel] [PATCH FYI 12/46] io: add QIOChannelTLS class
Quoted 36 lines · * Daniel P. Berrange ([email protected]) wrote:
Quoted 13 lines · Dr. David Alan Gilbert
Quoted 11 lines · * Daniel P. Berrange ([email protected]) wrote:
Add a QIOChannel subclass that can run the TLS protocol over the top of another QIOChannel instance. The object provides a simplified API to perform the handshake when starting the TLS session. The layering of TLS over the underlying channel does not have to be setup immediately. It is possible to take an existing QIOChannel that has done some handshake and then swap in the QIOChannelTLS layer. This allows for use with protocols which start TLS right away, and those which start plain text and then negotiate TLS.
Signed-off-by Daniel P. Berrange <[email protected]>Quoted 10 lines
io/channel-tls.c line 31
Quoted 6 lines
---
io/channel-tls.c new file +5
-0+#ifdef QIO_DEBUG +#define DPRINTF (fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) +#else +#define DPRINTF (fmt, ...) do { } while (0) +#endif Can you use the
trace_stuff rather than dprintf's; I've been trying to remove them all from the migration code (and with trace configured in stderr mode it works pretty easily).Yeah, that's a good idea.
Quoted 2 lines
On a different question; if this TLS channel is backed by a socket, can I do a shutdown call that will bubble down to the socket?
The QIOChannel abstract base class did not define any shutdown method, since that's not a generally applicable concept - essentially only the sockets interface can do that. So I defined it as a method just on the QIOChannelSocket class. Given this, the QIOChannelTLS class does not know about the shutdown call.
Quoted 4 lines
This isn't a big deal though - the QIOChannelTLS struct exposes a pointer to the underling QIOChannel transport, so code that needs to do a shutdown, can get hold of the underlying channel and call shutdown on that.
You can imagine something like compression->TLS->socket and then it gets
into the caller having to do a generic walk to figure out if it can do it; I'd rather not have to do that in caller.
I think I'd rather it was a facility on QIOChannel and then it gets some type of ENOTSUPP error if it hits a layer that doesn't support it; I guess the same might be true for socket behaviours like nagling and maybe blocking.
Quoted 3 lines
I forgot to do this properly when I integrated with the migration QEMUFile interface, so I'll fix that up, so shutdown works correctly with migration when TLS is enabled.
Dave
Quoted 8 lines
Regards,
DanielSignature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Re: [Qemu-devel] [PATCH FYI 12/46] io: add QIOChannelTLS class
Quoted 42 lines · Dr. David Alan Gilbert
Quoted 36 lines · * Daniel P. Berrange ([email protected]) wrote:
Quoted 13 lines · Dr. David Alan Gilbert
Quoted 11 lines · * Daniel P. Berrange ([email protected]) wrote:
Add a QIOChannel subclass that can run the TLS protocol over the top of another QIOChannel instance. The object provides a simplified API to perform the handshake when starting the TLS session. The layering of TLS over the underlying channel does not have to be setup immediately. It is possible to take an existing QIOChannel that has done some handshake and then swap in the QIOChannelTLS layer. This allows for use with protocols which start TLS right away, and those which start plain text and then negotiate TLS.
Signed-off-by Daniel P. Berrange <[email protected]>Quoted 10 lines
io/channel-tls.c line 31
Quoted 6 lines
---
io/channel-tls.c new file +5
-0+#ifdef QIO_DEBUG +#define DPRINTF (fmt, ...) do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) +#else +#define DPRINTF (fmt, ...) do { } while (0) +#endif Can you use the
trace_stuff rather than dprintf's; I've been trying to remove them all from the migration code (and with trace configured in stderr mode it works pretty easily).Yeah, that's a good idea.
Quoted 2 lines
On a different question; if this TLS channel is backed by a socket, can I do a shutdown call that will bubble down to the socket?
The QIOChannel abstract base class did not define any shutdown method, since that's not a generally applicable concept - essentially only the sockets interface can do that. So I defined it as a method just on the QIOChannelSocket class. Given this, the QIOChannelTLS class does not know about the shutdown call.
Quoted 4 lines
This isn't a big deal though - the QIOChannelTLS struct exposes a pointer to the underling QIOChannel transport, so code that needs to do a shutdown, can get hold of the underlying channel and call shutdown on that.
Quoted 7 lines
You can imagine something like
compression->TLS->socketand then it gets
into the caller having to do a generic walk to figure out if it can do it; I'd rather not have to do that in caller.
I think I'd rather it was a facility on QIOChannel and then it gets some type of ENOTSUPP error if it hits a layer that doesn't support it; I guess the same might be true for socket behaviours like nagling and maybe blocking.
Yeah, nagling I have defined as an API only on QIOChannelSocket. The blocking flag though was on the base QIOChannel interface.
On the QIOChannel interface I did in fact provide the facility to do UNIX FD passing, which is a UNIX socket only feature, along with a feature query mechanism. So I guess I already have precedent for putting such features in the base class. So I'll update this series to move some of those methods like shutdown, nagle, cork, in the base QIOChannel interface.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
PATCH 13/46 io: add QIOChannelWebsock class
In reply to Daniel P. BerrangeAdd a QIOChannel subclass that can run the websocket protocol over the top of another QIOChannel instance. This initial implementation is only capable of acting as a websockets server. There is no support for acting as a websockets client yet.
--- include/io/channel-websock.h | 108 +++++ io/Makefile.objs | 1 + io/channel-websock.c | 965 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1074 insertions(+) create mode 100644 include/io/channel-websock.h create mode 100644 io/channel-websock.c
include/io/channel-websock.h new file +108 -0
@@ -0,0 +1,108 @@ +/* +* QEMU I/O channels driver websockets +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QIO_CHANNEL_WEBSOCK_H__ +#define QIO_CHANNEL_WEBSOCK_H__ + +#include "io/channel.h" +#include "io/buffer.h" +#include "io/task.h" + +#define TYPE_QIO_CHANNEL_WEBSOCK "qio-channel-websock" +#define QIO_CHANNEL_WEBSOCK (obj) \ + OBJECT_CHECK(QIOChannelWebsock, (obj), TYPE_QIO_CHANNEL_WEBSOCK) + +typedef struct QIOChannelWebsock QIOChannelWebsock ; +typedef union QIOChannelWebsockMask QIOChannelWebsockMask ; + +union QIOChannelWebsockMask { +char c[4 ]; +uint32_t u; +}; + +/** +* QIOChannelWebsock +* +* The QIOChannelWebsock class provides a channel wrapper which +* can transparently run the HTTP websockets protocol. This is +* usually used over a TCP socket, but there is actually no +* technical restriction on which type of master channel is +* used as the transport. +* +* This channel object is currently only capable of running as +* a websocket server and is a pretty crude implementation +* of it, not supporting the full websockets protocol feature +* set. It is sufficient to use with a simple websockets +* client for encapsulating VNC for noVNC in-browser client. +*/ + +struct QIOChannelWebsock { +QIOChannel parent; +QIOChannel *master; +QIOBuffer encinput; +QIOBuffer encoutput; +QIOBuffer rawinput; +QIOBuffer rawoutput; +size_t payload_remain; +QIOChannelWebsockMask mask; +guint io_tag; +Error *io_err; +gboolean io_eof; +}; + +/** +* qio_channel_websock_new_server: +* @master: the underlying channel object +* +* Create a new websockets channel that runs the server +* side of the protocol. +* +* After creating the channel, it is mandatory to call +* the qio_channel_websock_handshake() method before attempting +* todo any I/O on the channel. +* +* Once the handshake has completed, all I/O should be done +* via the new websocket channel object and not the original +* master channel +* +* Returns: the new websockets channel object +*/ +QIOChannelWebsock * +qio_channel_websock_new_server (QIOChannel *master); + +/** +* qio_channel_websock_handshake: +* @ioc: the websocket channel object +* @func: the callback to invoke when completed +* @opaque: opaque data to pass to @func +* @destroy: optional callback to free @opaque +* +* Perform the websocket handshake. This method +* will return immediately and the handshake will +* continue in the background, provided the main +* loop is running. When the handshake is complete, +* or fails, the @func callback will be invoked. +*/ +void qio_channel_websock_handshake (QIOChannelWebsock *ioc, +QIOTaskFunc func, +gpointer opaque, +GDestroyNotify destroy); + +#endif /* QIO_CHANNEL_WEBSOCK_H__ */
io/Makefile.objs +1 -0
@@ -5,3 +5,4 @@ io-obj-y += channel-watch.o io-obj-y += channel-socket.o io-obj-y += channel-file.o io-obj-y += channel-tls.o +io-obj-y += channel-websock.o
io/channel-websock.c new file +965 -0
965 lines not on this page · raw message
Signature · 1 line
2.4.3
Re: [Qemu-devel] [PATCH FYI 13/46] io: add QIOChannelWebsock class
Quoted 172 lines · * Daniel P. Berrange ([email protected]) wrote:
Add a QIOChannel subclass that can run the websocket protocol over the top of another QIOChannel instance. This initial implementation is only capable of acting as a websockets server. There is no support for acting as a websockets client yet.
Signed-off-by Daniel P. Berrange <[email protected]>--- include/io/channel-websock.h | 108 +++++ io/Makefile.objs | 1 + io/channel-websock.c | 965 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1074 insertions(+) create mode 100644 include/io/channel-websock.h create mode 100644 io/channel-websock.cinclude/io/channel-websock.h new file +108
-0@@ -0,0 +1,108 @@ +/* +* QEMU I/O channels driver websockets +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QIO_CHANNEL_WEBSOCK_H__ +#define QIO_CHANNEL_WEBSOCK_H__ + +#include "io/channel.h" +#include "io/buffer.h" +#include "io/task.h" + +#define TYPE_QIO_CHANNEL_WEBSOCK "qio-channel-websock" +#define QIO_CHANNEL_WEBSOCK (obj) \ + OBJECT_CHECK(QIOChannelWebsock, (obj), TYPE_QIO_CHANNEL_WEBSOCK) + +typedef struct QIOChannelWebsock QIOChannelWebsock ; +typedef union QIOChannelWebsockMask QIOChannelWebsockMask ; + +union QIOChannelWebsockMask { +char c[4 ]; +uint32_t u; +}; + +/** +* QIOChannelWebsock +* +* The QIOChannelWebsock class provides a channel wrapper which +* can transparently run the HTTP websockets protocol. This is +* usually used over a TCP socket, but there is actually no +* technical restriction on which type of master channel is +* used as the transport. +* +* This channel object is currently only capable of running as +* a websocket server and is a pretty crude implementation +* of it, not supporting the full websockets protocol feature +* set. It is sufficient to use with a simple websockets +* client for encapsulating VNC for noVNC in-browser client. +*/ + +struct QIOChannelWebsock { +QIOChannel parent; +QIOChannel *master; +QIOBuffer encinput; +QIOBuffer encoutput; +QIOBuffer rawinput; +QIOBuffer rawoutput; +size_t payload_remain; +QIOChannelWebsockMask mask; +guint io_tag; +Error *io_err; +gboolean io_eof; +}; + +/** +* qio_channel_websock_new_server: +* @master: the underlying channel object +* +* Create a new websockets channel that runs the server +* side of the protocol. +* +* After creating the channel, it is mandatory to call +* the qio_channel_websock_handshake() method before attempting +* todo any I/O on the channel. +* +* Once the handshake has completed, all I/O should be done +* via the new websocket channel object and not the original +* master channel +* +* Returns: the new websockets channel object +*/ +QIOChannelWebsock * +qio_channel_websock_new_server (QIOChannel *master); + +/** +* qio_channel_websock_handshake: +* @ioc: the websocket channel object +* @func: the callback to invoke when completed +* @opaque: opaque data to pass to @func +* @destroy: optional callback to free @opaque +* +* Perform the websocket handshake. This method +* will return immediately and the handshake will +* continue in the background, provided the main +* loop is running. When the handshake is complete, +* or fails, the @func callback will be invoked. +*/ +void qio_channel_websock_handshake (QIOChannelWebsock *ioc, +QIOTaskFunc func, +gpointer opaque, +GDestroyNotify destroy); + +#endif /* QIO_CHANNEL_WEBSOCK_H__ */ io/Makefile.objs +1
-0@@ -5,3 +5,4 @@ io-obj-y += channel-watch.o io-obj-y += channel-socket.o io-obj-y += channel-file.o io-obj-y += channel-tls.o +io-obj-y += channel-websock.oio/channel-websock.c new file +29
-0@@ -0,0 +1,965 @@ +/* +* QEMU I/O channels driver websockets +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#include "io/channel-websock.h" +#include "crypto/hash.h" + +#include <glib/gi18n.h> + +/* #define DEBUG_IOC */ + +#ifdef DEBUG_IOC +#define DPRINTF (fmt, ...) \
io/channel-websock.c line 39
Quoted 10 lines
io/channel-websock.c new file +10
-0+ do { fprintf(stderr, "channel-websock: " fmt, ## __VA_ARGS__); } while (0) +#else +#define DPRINTF (fmt, ...) \ + do { } while (0) +#endif + +/* Max amount to allow in rawinput/rawoutput buffers */ +#define QIO_CHANNEL_WEBSOCK_MAX_BUFFER 8192 + +#define B64LEN (__x) (((__x + 2) / 3) * 12 / 3)
Where is that magic calculation used?
Quoted 190 lines
io/channel-websock.c new file +190
-0+#define SHA1_DIGEST_LEN 20 + +#define QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN 24 +#define QIO_CHANNEL_WEBSOCK_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" +#define QIO_CHANNEL_WEBSOCK_GUID_LEN strlen(QIO_CHANNEL_WEBSOCK_GUID) + +#define QIO_CHANNEL_WEBSOCK_HANDSHAKE_RESPONSE \ + "HTTP/1.1 101 Switching Protocols\r\n" \ + "Upgrade: websocket\r\n" \ + "Connection: Upgrade\r\n" \ + "Sec-WebSocket-Accept: %s\r\n" \ + "Sec-WebSocket-Protocol: binary\r\n" \ + "\r\n" +#define QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM "\r\n" +#define QIO_CHANNEL_WEBSOCK_HANDSHAKE_END "\r\n\r\n" +#define QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION "13" + +#define QIO_CHANNEL_WEBSOCK_HEAD_MIN_LEN sizeof(uint16_t) +#define QIO_CHANNEL_WEBSOCK_HEAD_MAX_LEN \ + (QIO_CHANNEL_WEBSOCK_HEAD_MIN_LEN + sizeof(uint64_t) + sizeof(uint32_t)) + +typedef struct QIOChannelWebsockHeader QIOChannelWebsockHeader ; + +struct QEMU_PACKED QIOChannelWebsockHeader { +unsigned char b0; +unsigned char b1; +union { +struct QEMU_PACKED { +uint16_t l16; +QIOChannelWebsockMask m16; + } s16; +struct QEMU_PACKED { +uint64_t l64; +QIOChannelWebsockMask m64; + } s64; +QIOChannelWebsockMask m; + } u; +}; + +enum { +QIO_CHANNEL_WEBSOCK_OPCODE_CONTINUATION =0x0 , +QIO_CHANNEL_WEBSOCK_OPCODE_TEXT_FRAME =0x1 , +QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME =0x2 , +QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE =0x8 , +QIO_CHANNEL_WEBSOCK_OPCODE_PING =0x9 , +QIO_CHANNEL_WEBSOCK_OPCODE_PONG =0xA +}; + +static char *qio_channel_websock_handshake_entry (const char *handshake, +size_t handshake_len, +const char *name) +{ +char *begin, *end, *ret =NULL ; +char *line =g_strdup_printf ("%s%s: " , +QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM , + name); + begin =g_strstr_len (handshake, handshake_len, line); +if (begin !=NULL ) { + begin +=strlen (line); + end =g_strstr_len (begin, handshake_len - (begin - handshake), +QIO_CHANNEL_WEBSOCK_HANDSHAKE_DELIM ); +if (end !=NULL ) { + ret =g_strndup (begin, end - begin); + } + } +g_free (line); +return ret; +} + + +static int qio_channel_websock_handshake_send_response (QIOChannelWebsock *ioc, +const char *key, +Error **errp) +{ +char combined_key[QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN + +QIO_CHANNEL_WEBSOCK_GUID_LEN +1 ]; +char *accept =NULL , *response =NULL ; +size_t responselen; + +g_strlcpy (combined_key, key,QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN +1 ); +g_strlcat (combined_key,QIO_CHANNEL_WEBSOCK_GUID , +QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN + +QIO_CHANNEL_WEBSOCK_GUID_LEN +1 ); + +/* hash and encode it */ +if (qcrypto_hash_base64 (QCRYPTO_HASH_ALG_SHA1 , + combined_key, +QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN + +QIO_CHANNEL_WEBSOCK_GUID_LEN , + &accept, + errp) <0 ) { +return -1 ; + } + + response =g_strdup_printf (QIO_CHANNEL_WEBSOCK_HANDSHAKE_RESPONSE , accept); + responselen =strlen (response); +qio_buffer_reserve (&ioc->encoutput, responselen); +qio_buffer_append (&ioc->encoutput, response, responselen); + +g_free (accept); +g_free (response); + +return 0 ; +} + +static int qio_channel_websock_handshake_process (QIOChannelWebsock *ioc, +const char *line, +size_t size, +Error **errp) +{ +int ret =-1 ; +char *protocols =qio_channel_websock_handshake_entry (line, size, +"Sec-WebSocket-Protocol" ); +char *version =qio_channel_websock_handshake_entry (line, size, +"Sec-WebSocket-Version" ); +char *key =qio_channel_websock_handshake_entry (line, size, +"Sec-WebSocket-Key" ); + +if (!protocols) { +error_setg (errp,"%s" ,_ ("Missing websocket protocol header data" )); + goto cleanup; + } + +if (!version) { +error_setg (errp,"%s" ,_ ("Missing websocket version header data" )); + goto cleanup; + } + +if (!key) { +error_setg (errp,"%s" ,_ ("Missing websocket key header data" )); + goto cleanup; + } + +if (!g_strrstr (protocols,"binary" )) { +error_setg (errp,_ ("No 'binary' protocol is supported by client '%s'" ), + protocols); + goto cleanup; + } + +if (!g_str_equal (version,QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION )) { +error_setg (errp,_ ("Version '%s' is not supported by client '%s'" ), +QIO_CHANNEL_WEBSOCK_SUPPORTED_VERSION , version); + goto cleanup; + } + +if (strlen (key) !=QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN ) { +error_setg (errp,_ ("Key length '%zu' was not as expected '%d'" ), +strlen (key),QIO_CHANNEL_WEBSOCK_CLIENT_KEY_LEN ); + goto cleanup; + } + + ret =qio_channel_websock_handshake_send_response (ioc, key, errp); + + cleanup: +g_free (protocols); +g_free (version); +g_free (key); +return ret; +} + +static int qio_channel_websock_handshake_read (QIOChannelWebsock *ioc, +Error **errp) +{ +char *handshake_end; +ssize_t ret; +/* Typical HTTP headers from novnc are 512 bytes, so limiting +* total header size to 4096 is easily enough. */ +size_t want =4096 - ioc->encinput.offset; +qio_buffer_reserve (&ioc->encinput, want); + ret =qio_channel_read (ioc->master, + (char *)qio_buffer_end (&ioc->encinput), want, errp); +if (ret <0 ) { +return -1 ; + } + ioc->encinput.offset += ret; + + handshake_end =g_strstr_len ((char *)ioc->encinput.buffer, + ioc->encinput.offset, +QIO_CHANNEL_WEBSOCK_HANDSHAKE_END ); +if (!handshake_end) { +if (ioc->encinput.offset >=4096 ) { +error_setg (errp,"%s" , +_ ("End of headers not found in first 4096 bytes" )); +return -1 ; + }else { +return 0 ; + } + } + + if (qio_channel_websock_handshake_process(ioc,
io/channel-websock.c line 239
Quoted 10 lines
io/channel-websock.c new file +10
-0+ (char *)ioc->encinput.buffer, + ioc->encinput.offset, + errp) < 0) { +return -1 ; + } + +qio_buffer_advance (&ioc->encinput, + handshake_end - (char *)ioc->encinput.buffer + +strlen (QIO_CHANNEL_WEBSOCK_HANDSHAKE_END )); +return 1 ;
Can you comment the return values for this function; I guess -1 is error, 1 is good, what's 0 ?
Quoted 79 lines
io/channel-websock.c new file +79
-0+static gboolean qio_channel_websock_handshake_send (QIOChannel *ioc, +GIOCondition condition, +gpointer user_data) +{ +QIOTask *task = user_data; +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK ( +qio_task_get_source (task)); +Error *err =NULL ; +ssize_t ret; + +DPRINTF ("Sending websock handshake reply %p\n" , wioc); + ret =qio_channel_write (wioc->master, + (char *)wioc->encoutput.buffer, + wioc->encoutput.offset, + &err); + +if (ret <0 ) { +qio_task_abort (task, err); +DPRINTF ("Error sending websock handshake reply %p: %s\n" , + wioc,error_get_pretty (err)); +error_free (err); +return FALSE; + } + +qio_buffer_advance (&wioc->encoutput, ret); +if (wioc->encoutput.offset ==0 ) { +DPRINTF ("Finished sending websock handshake %p\n" , + wioc); +qio_task_complete (task); +return FALSE; + } +return TRUE; +} + +static gboolean qio_channel_websock_handshake_io (QIOChannel *ioc, +GIOCondition condition, +gpointer user_data) +{ +QIOTask *task = user_data; +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK ( +qio_task_get_source (task)); +Error *err =NULL ; +int ret; + +DPRINTF ("Reading websock handshake request %p\n" , wioc); + ret =qio_channel_websock_handshake_read (wioc, &err); +if (ret <0 ) { +DPRINTF ("Error reading websock handshake %s\n" , +error_get_pretty (err)); +qio_task_abort (task, err); +error_free (err); +return FALSE; + } +if (ret ==0 ) { +DPRINTF ("Blocking on more request data\n" ); +/* need more data still */ +return TRUE; + } + +DPRINTF ("Websock request complete, adding watch for reply %p\n" , + wioc); + +object_ref (OBJECT (task)); +qio_channel_add_watch ( + wioc->master, +G_IO_OUT , + qio_channel_websock_handshake_send, + task, + (GDestroyNotify )object_unref); +return FALSE; +} + + +static void qio_channel_websock_encode (QIOChannelWebsock *ioc) +{ +size_t header_size =0 ; +unsigned char opcode =QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME ; +union { +char buf[QIO_CHANNEL_WEBSOCK_HEAD_MAX_LEN ];
io/channel-websock.c line 330
Quoted 10 lines
io/channel-websock.c new file +10
-0+QIOChannelWebsockHeader ws; + } header; + +DPRINTF ("Encoding pending raw output %zu %p\n" , + ioc->rawoutput.offset, ioc); +if (!ioc->rawoutput.offset) { +return ; + } + + header.ws.b0 =0x80 | (opcode &0x0f );
There are quite a few magic header sizes 125, (and I think I saw some other sizes below) - some comments on them, or constants?
io/channel-websock.c line 331
Quoted 1 line
io/channel-websock.c new file +1
-0+if (ioc->rawoutput.offset <=125 ) {
Dave
Quoted 637 lines
io/channel-websock.c new file +634
-0+ header.ws.b1 = (uint8_t )ioc->rawoutput.offset; + header_size =2 ; + }else if (ioc->rawoutput.offset <65536 ) { + header.ws.b1 =0x7e ; + header.ws.u.s16.l16 =cpu_to_be16 ((uint16_t )ioc->rawoutput.offset); + header_size =4 ; + }else { + header.ws.b1 =0x7f ; + header.ws.u.s64.l64 =cpu_to_be64 (ioc->rawoutput.offset); + header_size =10 ; + } + +qio_buffer_reserve (&ioc->encoutput, header_size + ioc->rawoutput.offset); +qio_buffer_append (&ioc->encoutput, header.buf, header_size); +qio_buffer_append (&ioc->encoutput, ioc->rawoutput.buffer, + ioc->rawoutput.offset); +qio_buffer_reset (&ioc->rawoutput); +DPRINTF ("Have %zu bytes encoded output %p\n" , + ioc->encoutput.offset, ioc); +} + + +static ssize_t qio_channel_websock_decode_header (QIOChannelWebsock *ioc, +Error **errp) +{ +unsigned char opcode =0 , fin =0 , has_mask =0 ; +size_t header_size =0 ; +size_t payload_len; +QIOChannelWebsockHeader *header = + (QIOChannelWebsockHeader *)ioc->encinput.buffer; + +if (ioc->payload_remain) { +error_setg (errp, +_ ("Decoding header but %zu bytes of payload remain" ), + ioc->payload_remain); +return -1 ; + } +if (ioc->encinput.offset <QIO_CHANNEL_WEBSOCK_HEAD_MIN_LEN +4 ) { +/* header not complete */ +return QIO_CHANNEL_ERR_BLOCK ; + } + + fin = (header->b0 &0x80 ) >>7 ; + opcode = header->b0 &0x0f ; + has_mask = (header->b1 &0x80 ) >>7 ; + payload_len = header->b1 &0x7f ; + +if (opcode ==QIO_CHANNEL_WEBSOCK_OPCODE_CLOSE ) { +/* disconnect */ +return 0 ; + } + +/* Websocket frame sanity check: +* * Websocket fragmentation is not supported. +* * All websockets frames sent by a client have to be masked. +* * Only binary encoding is supported. +*/ +if (!fin) { +error_setg (errp,"%s" ,_ ("websocket fragmentation is not supported" )); +return -1 ; + } +if (!has_mask) { +error_setg (errp,"%s" ,_ ("websocket frames must be masked" )); +return -1 ; + } +if (opcode !=QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME ) { +error_setg (errp,"%s" ,_ ("only binary websocket frames are supported" )); +return -1 ; + } + +if (payload_len <126 ) { + ioc->payload_remain = payload_len; + header_size =6 ; + ioc->mask = header->u.m; + }else if (payload_len ==126 && ioc->encinput.offset >=8 ) { + ioc->payload_remain =be16_to_cpu (header->u.s16.l16); + header_size =8 ; + ioc->mask = header->u.s16.m16; + }else if (payload_len ==127 && ioc->encinput.offset >=14 ) { + ioc->payload_remain =be64_to_cpu (header->u.s64.l64); + header_size =14 ; + ioc->mask = header->u.s64.m64; + }else { +/* header not complete */ +return QIO_CHANNEL_ERR_BLOCK ; + } + +qio_buffer_advance (&ioc->encinput, header_size); +return 1 ; +} + + +static ssize_t qio_channel_websock_decode_payload (QIOChannelWebsock *ioc, +Error **errp) +{ +size_t i; +size_t payload_len; +uint32_t *payload32; + +if (!ioc->payload_remain) { +error_setg (errp,"%s" , +_ ("Decoding payload but no bytes of payload remain" )); +return -1 ; + } + +/* If we aren't at the end of the payload, then drop +* off the last bytes, so we're always multiple of 4 +* for purpose of unmasking, except at end of payload +*/ +if (ioc->encinput.offset < ioc->payload_remain) { + payload_len = ioc->encinput.offset - (ioc->encinput.offset %4 ); + }else { + payload_len = ioc->payload_remain; + } +if (payload_len ==0 ) { +return QIO_CHANNEL_ERR_BLOCK ; + } + + ioc->payload_remain -= payload_len; + +/* unmask frame */ +/* process 1 frame (32 bit op) */ + payload32 = (uint32_t *)ioc->encinput.buffer; +for (i =0 ; i < payload_len /4 ; i++) { + payload32[i] ^= ioc->mask.u; + } +/* process the remaining bytes (if any) */ +for (i *=4 ; i < payload_len; i++) { + ioc->encinput.buffer[i] ^= ioc->mask.c[i %4 ]; + } + +qio_buffer_reserve (&ioc->rawinput, payload_len); +qio_buffer_append (&ioc->rawinput, ioc->encinput.buffer, payload_len); +qio_buffer_advance (&ioc->encinput, payload_len); +return payload_len; +} + + +QIOChannelWebsock * +qio_channel_websock_new_server (QIOChannel *master) +{ +QIOChannelWebsock *wioc; + + wioc =QIO_CHANNEL_WEBSOCK (object_new (TYPE_QIO_CHANNEL_WEBSOCK )); + + wioc->master = master; +object_ref (OBJECT (master)); + +return wioc; +} + +void qio_channel_websock_handshake (QIOChannelWebsock *ioc, +QIOTaskFunc func, +gpointer opaque, +GDestroyNotify destroy) +{ +QIOTask *task; + + task =qio_task_new (OBJECT (ioc), + func, + opaque, + destroy); + +DPRINTF ("Adding watch on master %p for websocket %p handshake\n" , + ioc->master, ioc); +qio_channel_add_watch (ioc->master, +G_IO_IN , + qio_channel_websock_handshake_io, + task, +NULL ); +} + +static void qio_channel_websock_init(Object *obj G_GNUC_UNUSED) +{ +} + + +static void qio_channel_websock_finalize (Object *obj) +{ +QIOChannelWebsock *ioc =QIO_CHANNEL_WEBSOCK (obj); + +qio_buffer_free (&ioc->encinput); +qio_buffer_free (&ioc->encoutput); +qio_buffer_free (&ioc->rawinput); +qio_buffer_free (&ioc->rawoutput); +object_unref (OBJECT (ioc->master)); +if (ioc->io_tag) { +g_source_remove (ioc->io_tag); + } +if (ioc->io_err) { +error_free (ioc->io_err); + } +} + + +static ssize_t qio_channel_websock_read_wire (QIOChannelWebsock *ioc, +Error **errp) +{ +ssize_t ret; + +DPRINTF ("Have %zu bytes %p\n" , ioc->encoutput.offset, ioc); +if (ioc->encinput.offset <4096 ) { +size_t want =4096 - ioc->encinput.offset; + +qio_buffer_reserve (&ioc->encinput, want); + ret =qio_channel_read (ioc->master, + (char *)ioc->encinput.buffer + + ioc->encinput.offset, + want, + errp); +if (ret <0 ) { +return ret; + } +if (ret ==0 && + ioc->encinput.offset ==0 ) { +DPRINTF ("EOF on wire & no more enc data availabl\n" ); +return 0 ; + } + ioc->encinput.offset += ret; +DPRINTF ("Now have %zu bytes enc input\n" , ioc->encinput.offset); + } + +if (ioc->payload_remain ==0 ) { +DPRINTF ("Looking to decode header\n" ); + ret =qio_channel_websock_decode_header (ioc, errp); +if (ret <0 ) { +return ret; + } +if (ret ==0 ) { +DPRINTF ("EOF when decoding header\n" ); +return 0 ; + } + } +DPRINTF ("Looking to decode payload %zu\n" , ioc->payload_remain); + + ret =qio_channel_websock_decode_payload (ioc, errp); +if (ret <0 ) { +return ret; + } +DPRINTF ("Now have %zu bytes raw input\n" , ioc->rawinput.offset); +return ret; +} + + +static ssize_t qio_channel_websock_write_wire (QIOChannelWebsock *ioc, +Error **errp) +{ +ssize_t ret; +ssize_t done =0 ; +qio_channel_websock_encode (ioc); + +DPRINTF ("Writing %zu bytes %p\n" , ioc->encoutput.offset, ioc); +while (ioc->encoutput.offset >0 ) { + ret =qio_channel_write (ioc->master, + (char *)ioc->encoutput.buffer, + ioc->encoutput.offset, + errp); +if (ret <0 ) { +if (ret ==QIO_CHANNEL_ERR_BLOCK && + done >0 ) { +DPRINTF ("Blocking but wrote %zu\n" , done); +return done; + }else { +DPRINTF ("Error while writing %s\n" , +error_get_pretty (*errp)); +return ret; + } + } +qio_buffer_advance (&ioc->encoutput, ret); + done += ret; + } +DPRINTF ("Wrote %zu total\n" , done); +return done; +} + + +static void qio_channel_websock_flush_free (gpointer user_data) +{ +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK (user_data); +object_unref (OBJECT (wioc)); +} + +static void qio_channel_websock_set_watch (QIOChannelWebsock *ioc); + +static gboolean qio_channel_websock_flush (QIOChannel *ioc, +GIOCondition condition, +gpointer user_data) +{ +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK (user_data); +ssize_t ret; + +DPRINTF ("Websock master flush %p %d\n" , ioc, condition); +if (condition &G_IO_OUT ) { + ret =qio_channel_websock_write_wire (wioc, &wioc->io_err); +if (ret <0 ) { + goto cleanup; + } + } + +if (condition &G_IO_IN ) { + ret =qio_channel_websock_read_wire (wioc, &wioc->io_err); +if (ret <0 ) { + goto cleanup; + } +if (ret ==0 ) { +DPRINTF ("Got EOF when reading %p\n" , wioc); + wioc->io_eof = TRUE; + } + } + + cleanup: +qio_channel_websock_set_watch (wioc); +return FALSE; +} + + +static void qio_channel_websock_unset_watch (QIOChannelWebsock *ioc) +{ +if (ioc->io_tag) { +DPRINTF ("Removing old master watch %u %p\n" , ioc->io_tag, ioc); +g_source_remove (ioc->io_tag); + ioc->io_tag =0 ; + } +} + +static void qio_channel_websock_set_watch (QIOChannelWebsock *ioc) +{ +GIOCondition cond =0 ; + +qio_channel_websock_unset_watch (ioc); + +if (ioc->io_err) { +DPRINTF ("Not adding master watch due to error %p %s\n" , + ioc,error_get_pretty (ioc->io_err)); +return ; + } + +if (ioc->encoutput.offset) { + cond |=G_IO_OUT ; + } +if (ioc->encinput.offset <QIO_CHANNEL_WEBSOCK_MAX_BUFFER && + !ioc->io_eof) { + cond |=G_IO_IN ; + } + +DPRINTF ("Cond %d output=%zu input=%zu eof=%d\n" , + cond, ioc->encoutput.offset, ioc->encinput.offset, ioc->io_eof); +if (cond) { +object_ref (OBJECT (ioc)); + ioc->io_tag = +qio_channel_add_watch (ioc->master, + cond, + qio_channel_websock_flush, + ioc, + qio_channel_websock_flush_free); + } +} + + +static ssize_t qio_channel_websock_readv (QIOChannel *ioc, +const struct iovec *iov, +size_t niov, +int **fds, +size_t *nfds, +Error **errp) +{ +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK (ioc); +size_t i; +ssize_t got =0 ; +ssize_t ret; +DPRINTF ("Read ioc %p %zu %p\n" , iov, niov, ioc); +if (fds || nfds) { +error_setg (errp,"%s" , +_ ("Cannot receive file descriptors over websocket channel" )); +return -1 ; + } + +if (wioc->io_err) { + *errp =error_copy (wioc->io_err); +return -1 ; + } + +if (!wioc->rawinput.offset) { + ret =qio_channel_websock_read_wire (QIO_CHANNEL_WEBSOCK (ioc), errp); +if (ret <0 ) { +return ret; + } + } + +for (i =0 ; i < niov ; i++) { +size_t want = iov[i].iov_len; +if (want > (wioc->rawinput.offset - got)) { + want = (wioc->rawinput.offset - got); + } + +memcpy (iov[i].iov_base, + wioc->rawinput.buffer + got, + want); + got += want; + +if (want < iov[i].iov_len) { +break ; + } + } + +qio_buffer_advance (&wioc->rawinput, got); +qio_channel_websock_set_watch (wioc); +DPRINTF ("Returning %zu\n" , got); +return got; +} + + +static ssize_t qio_channel_websock_writev (QIOChannel *ioc, +const struct iovec *iov, +size_t niov, +int *fds, +size_t nfds, +Error **errp) +{ +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK (ioc); +size_t i; +ssize_t done =0 ; +ssize_t ret; + +if (fds || nfds) { +error_setg (errp,"%s" , +_ ("Cannot send file descriptors over websocket channel" )); +return -1 ; + } + +DPRINTF ("Writev %p %zu %p err=%p\n" , iov, niov, ioc, wioc->io_err); +if (wioc->io_err) { + *errp =error_copy (wioc->io_err); +return -1 ; + } + +if (wioc->io_eof) { +error_setg (errp,"%s" ,"Broken pipe" ); +return -1 ; + } + +for (i =0 ; i < niov; i++) { +size_t want = iov[i].iov_len; +if ((want + wioc->rawoutput.offset) >QIO_CHANNEL_WEBSOCK_MAX_BUFFER ) { + want = (QIO_CHANNEL_WEBSOCK_MAX_BUFFER - wioc->rawoutput.offset); + } +if (want ==0 ) { + goto done; + } + +qio_buffer_reserve (&wioc->rawoutput, want); +qio_buffer_append (&wioc->rawoutput, iov[i].iov_base, want); + done += want; +if (want < iov[i].iov_len) { +break ; + } + } + + done: + ret =qio_channel_websock_write_wire (wioc, errp); +if (ret <0 && + ret !=QIO_CHANNEL_ERR_BLOCK ) { +qio_channel_websock_unset_watch (wioc); +return -1 ; + } + +qio_channel_websock_set_watch (wioc); + +if (done ==0 ) { +return QIO_CHANNEL_ERR_BLOCK ; + } + +return done; +} + +static void qio_channel_websock_set_blocking (QIOChannel *ioc, +bool enabled) +{ +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK (ioc); + +qio_channel_set_blocking (wioc->master, enabled); +} + +static int qio_channel_websock_close (QIOChannel *ioc, +Error **errp) +{ +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK (ioc); + +return qio_channel_close (wioc->master, errp); +} + +typedef struct QIOChannelWebsockSource QIOChannelWebsockSource ; +struct QIOChannelWebsockSource { +GSource parent; +QIOChannelWebsock *wioc; +GIOCondition condition; +}; + +static gboolean +qio_channel_websock_source_prepare (GSource *source, +gint *timeout) +{ +QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source; +GIOCondition cond =0 ; + *timeout =-1 ; + +if (wsource->wioc->rawinput.offset) { + cond |=G_IO_IN ; + } +if (wsource->wioc->rawoutput.offset <QIO_CHANNEL_WEBSOCK_MAX_BUFFER ) { + cond |=G_IO_OUT ; + } + +#if 0 +DPRINTF ("Prep source %d cond %d input=%zu output=%zu\n" , + wsource->condition, cond, + wsource->wioc->rawinput.offset, + wsource->wioc->rawoutput.offset); +#endif + +return cond & wsource->condition; +} + +static gboolean +qio_channel_websock_source_check (GSource *source) +{ +QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source; +GIOCondition cond =0 ; + +if (wsource->wioc->rawinput.offset) { + cond |=G_IO_IN ; + } +if (wsource->wioc->rawoutput.offset <QIO_CHANNEL_WEBSOCK_MAX_BUFFER ) { + cond |=G_IO_OUT ; + } + +if (cond & wsource->condition) { +DPRINTF ("Check source %d cond %d input=%zu output=%zu\n" , + wsource->condition, cond, + wsource->wioc->rawinput.offset, + wsource->wioc->rawoutput.offset); + } +return cond & wsource->condition; +} + +static gboolean +qio_channel_websock_source_dispatch (GSource *source, +GSourceFunc callback, +gpointer user_data) +{ +QIOChannelFunc func = (QIOChannelFunc )callback; +QIOChannelWebsockSource *wsource = (QIOChannelWebsockSource *)source; +GIOCondition cond =0 ; + +if (wsource->wioc->rawinput.offset) { + cond |=G_IO_IN ; + } +if (wsource->wioc->rawoutput.offset <QIO_CHANNEL_WEBSOCK_MAX_BUFFER ) { + cond |=G_IO_OUT ; + } + +DPRINTF ("Disp source %d cond %d input=%zu output=%zu\n" , + wsource->condition, cond, + wsource->wioc->rawinput.offset, + wsource->wioc->rawoutput.offset); +return (*func)(QIO_CHANNEL (wsource->wioc), + (cond & wsource->condition), + user_data); +} + +static void +qio_channel_websock_source_finalize (GSource *source) +{ +QIOChannelWebsockSource *ssource = (QIOChannelWebsockSource *)source; + +object_unref (OBJECT (ssource->wioc)); +} + +GSourceFuncs qio_channel_websock_source_funcs = { + qio_channel_websock_source_prepare, + qio_channel_websock_source_check, + qio_channel_websock_source_dispatch, + qio_channel_websock_source_finalize +}; + +static GSource *qio_channel_websock_create_watch (QIOChannel *ioc, +GIOCondition condition) +{ +QIOChannelWebsock *wioc =QIO_CHANNEL_WEBSOCK (ioc); +QIOChannelWebsockSource *ssource; +GSource *source; + +DPRINTF ("Creating websock watch %p cond=%d\n" , wioc, condition); + source =g_source_new (&qio_channel_websock_source_funcs, +sizeof (QIOChannelWebsockSource)); +g_source_set_name (source,"QIOChannelWebsock" ); + ssource = (QIOChannelWebsockSource *)source; + + ssource->wioc = wioc; +object_ref (OBJECT (wioc)); + + ssource->condition = condition; + +qio_channel_websock_set_watch (wioc); +return source; +} + +static void qio_channel_websock_class_init (ObjectClass *klass, + void *class_data G_GNUC_UNUSED) +{ +QIOChannelClass *ioc_klass =QIO_CHANNEL_CLASS (klass); + + ioc_klass->io_writev = qio_channel_websock_writev; + ioc_klass->io_readv = qio_channel_websock_readv; + ioc_klass->io_set_blocking = qio_channel_websock_set_blocking; + ioc_klass->io_close = qio_channel_websock_close; + ioc_klass->io_create_watch = qio_channel_websock_create_watch; +} + +static const TypeInfo qio_channel_websock_info = { + .parent =TYPE_QIO_CHANNEL , + .name =TYPE_QIO_CHANNEL_WEBSOCK , + .instance_size =sizeof (QIOChannelWebsock), + .instance_init = qio_channel_websock_init, + .instance_finalize = qio_channel_websock_finalize, + .class_init = qio_channel_websock_class_init, +}; + +static void qio_channel_websock_register_types (void ) +{ +type_register_static (&qio_channel_websock_info); +} + +type_init (qio_channel_websock_register_types);Signature · 1 line
2.4.3
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Re: [Qemu-devel] [PATCH FYI 13/46] io: add QIOChannelWebsock class
Quoted 36 lines · Dr. David Alan Gilbert
Quoted 35 lines · * Daniel P. Berrange ([email protected]) wrote:
Add a QIOChannel subclass that can run the websocket protocol over the top of another QIOChannel instance. This initial implementation is only capable of acting as a websockets server. There is no support for acting as a websockets client yet.
Signed-off-by Daniel P. Berrange <[email protected]>--- include/io/channel-websock.h | 108 +++++ io/Makefile.objs | 1 + io/channel-websock.c | 965 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1074 insertions(+) create mode 100644 include/io/channel-websock.h create mode 100644 io/channel-websock.cio/channel-websock.c new file +14
-0@@ -0,0 +1,965 @@ + +#include "io/channel-websock.h" +#include "crypto/hash.h" + +#include <glib/gi18n.h> + +/* #define DEBUG_IOC */ + +#ifdef DEBUG_IOC +#define DPRINTF (fmt, ...) \ + do { fprintf(stderr, "channel-websock: " fmt, ## __VA_ARGS__); } while (0) +#else +#define DPRINTF (fmt, ...) \ + do { } while (0)
Quoted 8 lines
io/channel-websock.c line 39
Quoted 6 lines
io/channel-websock.c new file +6
-0+#endif + +/* Max amount to allow in rawinput/rawoutput buffers */ +#define QIO_CHANNEL_WEBSOCK_MAX_BUFFER 8192 + +#define B64LEN (__x) (((__x + 2) / 3) * 12 / 3)Where is that magic calculation used?
I copied these constants from the current ui/vnc-ws.h header file originally. In there it was referenced by another constant WS_ACCEPT_LEN, which was itself unused. I deleted WS_ACCEPT_LEN when I found it unused, but forgot to delete this B64LEN too.
Quoted 35 lines
Quoted 35 lines
io/channel-websock.c new file +35
-0+static int qio_channel_websock_handshake_read (QIOChannelWebsock *ioc, +Error **errp) +{ +char *handshake_end; +ssize_t ret; +/* Typical HTTP headers from novnc are 512 bytes, so limiting +* total header size to 4096 is easily enough. */ +size_t want =4096 - ioc->encinput.offset; +qio_buffer_reserve (&ioc->encinput, want); + ret =qio_channel_read (ioc->master, + (char *)qio_buffer_end (&ioc->encinput), want, errp); +if (ret <0 ) { +return -1 ; + } + ioc->encinput.offset += ret; + + handshake_end =g_strstr_len ((char *)ioc->encinput.buffer, + ioc->encinput.offset, +QIO_CHANNEL_WEBSOCK_HANDSHAKE_END ); +if (!handshake_end) { +if (ioc->encinput.offset >=4096 ) { +error_setg (errp,"%s" , +_ ("End of headers not found in first 4096 bytes" )); +return -1 ; + }else { +return 0 ; + } + } + +if (qio_channel_websock_handshake_process (ioc, + (char *)ioc->encinput.buffer, + ioc->encinput.offset, + errp) <0 ) { +return -1 ; + }
Quoted 8 lines
io/channel-websock.c line 239
Quoted 5 lines
io/channel-websock.c new file +5
-0+ +qio_buffer_advance (&ioc->encinput, + handshake_end - (char *)ioc->encinput.buffer + +strlen (QIO_CHANNEL_WEBSOCK_HANDSHAKE_END )); +return 1 ;Can you comment the return values for this function; I guess -1 is error, 1 is good, what's 0 ?
1 means we've read the full handshake response, 0 means we need to receive more data still.
Quoted 11 lines
Quoted 11 lines
io/channel-websock.c new file +11
-0+static void qio_channel_websock_encode (QIOChannelWebsock *ioc) +{ +size_t header_size =0 ; +unsigned char opcode =QIO_CHANNEL_WEBSOCK_OPCODE_BINARY_FRAME ; +union { +char buf[QIO_CHANNEL_WEBSOCK_HEAD_MAX_LEN ]; +QIOChannelWebsockHeader ws; + } header; + +DPRINTF ("Encoding pending raw output %zu %p\n" , + ioc->rawoutput.offset, ioc);
Quoted 8 lines
io/channel-websock.c line 330
Quoted 5 lines
io/channel-websock.c new file +5
-0+if (!ioc->rawoutput.offset) { +return ; + } + + header.ws.b0 =0x80 | (opcode &0x0f );There are quite a few magic header sizes 125, (and I think I saw some other sizes below) - some comments on them, or constants?
This code was derived from ui/vnc-ws.c which is full of magic, so I've mostly just inherited decisions made by that original author. I'll fix up this new code to be less magic and use constants and/or comments to clarify
Quoted 17 lines
io/channel-websock.c line 331
Quoted 2 lines
io/channel-websock.c new file +1
-0+if (ioc->rawoutput.offset <=125 ) {Dave
Quoted 12 lines
io/channel-websock.c new file +12
-0+ header.ws.b1 = (uint8_t )ioc->rawoutput.offset; + header_size =2 ; + }else if (ioc->rawoutput.offset <65536 ) { + header.ws.b1 =0x7e ; + header.ws.u.s16.l16 =cpu_to_be16 ((uint16_t )ioc->rawoutput.offset); + header_size =4 ; + }else { + header.ws.b1 =0x7f ; + header.ws.u.s64.l64 =cpu_to_be64 (ioc->rawoutput.offset); + header_size =10 ; + } +
Quoted 8 lines
io/channel-websock.c line 351
Quoted 8 lines
io/channel-websock.c new file +8
-0+qio_buffer_reserve (&ioc->encoutput, header_size + ioc->rawoutput.offset); +qio_buffer_append (&ioc->encoutput, header.buf, header_size); +qio_buffer_append (&ioc->encoutput, ioc->rawoutput.buffer, + ioc->rawoutput.offset); +qio_buffer_reset (&ioc->rawoutput); +DPRINTF ("Have %zu bytes encoded output %p\n" , + ioc->encoutput.offset, ioc); +}
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
PATCH 14/46 io: add QIOChannelCommand class
In reply to Daniel P. BerrangeAdd a QIOChannel subclass that is capable of performing I/O to/from a separate process, via a pair of pipes. The command can be used for unidirectional or bi-directional I/O.
--- include/io/channel-command.h | 91 ++++++++++ io/Makefile.objs | 1 + io/channel-command.c | 370 ++++++++++++++++++++++++++++++++++++++++ tests/.gitignore | 2 + tests/Makefile | 3 + tests/test-io-channel-command.c | 121 +++++++++++++ 6 files changed, 588 insertions(+) create mode 100644 include/io/channel-command.h create mode 100644 io/channel-command.c create mode 100644 tests/test-io-channel-command.c
include/io/channel-command.h new file +91 -0
@@ -0,0 +1,91 @@ +/* +* QEMU I/O channels external command driver +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QIO_CHANNEL_COMMAND_H__ +#define QIO_CHANNEL_COMMAND_H__ + +#include "io/channel.h" + +#define TYPE_QIO_CHANNEL_COMMAND "qio-channel-command" +#define QIO_CHANNEL_COMMAND (obj) \ + OBJECT_CHECK(QIOChannelCommand, (obj), TYPE_QIO_CHANNEL_COMMAND) + +typedef struct QIOChannelCommand QIOChannelCommand ; + + +/** +* QIOChannelCommand: +* +* The QIOChannelCommand class provides a channel implementation +* that can transport data with an externally running command +* via its stdio streams. +*/ + +struct QIOChannelCommand { +QIOChannel parent; +int writefd; +int readfd; +pid_t pid; +}; + + +/** +* qio_channel_command_new_pid: +* @writefd: the FD connected to the command's stdin +* @readfd: the FD connected to the command's stdout +* @pid: the PID of the running child command +* @errp: pointer to an uninitialized error object +* +* Create a channel for performing I/O with the +* previously spawned command identified by @pid. +* The two file descriptors provide the connection +* to command's stdio streams, either one or which +* may be -1 to indicate that stream is not open. +* +* The channel will take ownership of the process +* @pid and will kill it when closing the channel. +* Similarly it will take responsibility for +* closing the file descriptors @writefd and @readfd. +* +* Returns: the command channel object, or NULL on error +*/ +QIOChannelCommand * +qio_channel_command_new_pid (int writefd, +int readfd, +pid_t pid); + +/** +* qio_channel_command_new_spawn: +* @argv: the NULL terminated list of command arguments +* @flags: the I/O mode, one of O_RDONLY, O_WRONLY, O_RDWR +* @errp: pointer to an uninitialized error object +* +* Create a channel for performing I/O with the +* command to be spawned with arguments @argv. +* +* Returns: the command channel object, or NULL on error +*/ +QIOChannelCommand * +qio_channel_command_new_spawn (const char *const argv[], +int flags, +Error **errp); + + +#endif /* QIO_CHANNEL_COMMAND_H__ */
io/Makefile.objs +1 -0
@@ -6,3 +6,4 @@ io-obj-y += channel-socket.o io-obj-y += channel-file.o io-obj-y += channel-tls.o io-obj-y += channel-websock.o +io-obj-y += channel-command.o
io/channel-command.c new file +370 -0
370 lines not on this page · raw message
tests/.gitignore +2 -0
@@ -23,6 +23,8 @@ test-cutils test-hbitmap test-int128 test-iov +test-io-channel-command +test-io-channel-command.fifo test-io-channel-file test-io-channel-file.txt test-io-channel-socket
tests/Makefile +3 -0
@@ -82,6 +82,7 @@ check-unit-y += tests/test-io-task$(EXESUF) check-unit-y += tests/test-io-channel-socket$(EXESUF) check-unit-y += tests/test-io-channel-file$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-io-channel-tls$(EXESUF) +check-unit-y += tests/test-io-channel-command$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -370,6 +371,8 @@ tests/test-io-channel-file$(EXESUF): tests/test-io-channel-file.o \ tests/test-io-channel-tls$(EXESUF): tests/test-io-channel-tls.o \ tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o \ tests/io-channel-helpers.o $(test-io-obj-y) +tests/test-io-channel-command$(EXESUF): tests/test-io-channel-command.o \ + tests/io-channel-helpers.o $(test-io-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
tests/test-io-channel-command.c new file +121 -0
121 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 15/46 ui: convert VNC startup code to use SocketAddress
In reply to Daniel P. BerrangeThe VNC code is currently using QemuOpts to configure the sockets connections / listeners it needs. Convert it to use SocketAddress to bring it in line with modern QAPI based code elsewhere in QEMU.
--- ui/vnc.c | 161 ++++++++++++++++++++++++++++++++++++--------------------------- 1 file changed, 91 insertions(+), 70 deletions(-)
ui/vnc.c +91 -70
@@ -3463,18 +3463,14 @@ void vnc_display_open(const char *id, Error **errp) {VncDisplay *vs =vnc_display_find (id);QemuOpts *opts =qemu_opts_find (&qemu_vnc_opts, id); -QemuOpts *sopts, *wsopts; +SocketAddress *saddr =NULL , *wsaddr =NULL ;const char *share, *device_id;QemuConsole *con;bool password = false;bool reverse = false;const char *vnc; -const char *has_to;char *h; -bool has_ipv4 = false; -bool has_ipv6 = false;const char *credid; -const char *websocket;bool sasl = false;#ifdef CONFIG_VNC_SASL int saslErr;
@@ -3496,44 +3492,83 @@ void vnc_display_open(const char *id, Error **errp)return ; } - sopts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort); - wsopts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort); - h =strrchr (vnc,':' );if (h) { -char *host;size_t hlen = h - vnc; -if (vnc[0 ] =='[' && vnc[hlen -1 ] ==']' ) { - host =g_strndup (vnc +1 , hlen -2 ); +const char *websocket =qemu_opt_get (opts,"websocket" ); +const char *has_to =qemu_opt_get (opts,"to" ); +bool has_ipv4 =qemu_opt_get_bool (opts,"ipv4" , false); +bool has_ipv6 =qemu_opt_get_bool (opts,"ipv6" , false); + + saddr =g_new0 (SocketAddress,1 ); +if (websocket) { +if (!qcrypto_hash_supports (QCRYPTO_HASH_ALG_SHA1 )) { +error_setg (errp, +"SHA1 hash support is required for websockets" ); + goto fail; + } + + wsaddr =g_new0 (SocketAddress,1 ); + vs->ws_enabled = true; + } + +if (strncmp (vnc,"unix:" ,5 ) ==0 ) { + saddr->kind =SOCKET_ADDRESS_KIND_UNIX ; + saddr->q_unix =g_new0 (UnixSocketAddress,1 ); + saddr->q_unix->path =g_strdup (vnc +5 ); + +if (vs->ws_enabled) { +error_setg (errp,"UNIX sockets not supported with websock" ); + goto fail; + } }else { - host =g_strndup (vnc, hlen); +unsigned long long baseport; + saddr->kind =SOCKET_ADDRESS_KIND_INET ; + saddr->inet =g_new0 (InetSocketAddress,1 ); +if (vnc[0 ] =='[' && vnc[hlen -1 ] ==']' ) { + saddr->inet->host =g_strndup (vnc +1 , hlen -2 ); + }else { + saddr->inet->host =g_strndup (vnc, hlen); + } +if (parse_uint_full (h +1 , &baseport,10 ) <0 ) { +error_setg (errp,"can't convert to a number: %s" , h +1 ); + goto fail; + } +if (baseport >65535 || + baseport +5900 >65535 ) { +error_setg (errp,"port %s out of range" , h +1 ); + goto fail; + } + saddr->inet->port =g_strdup_printf ( +"%d" , (int )baseport +5900 ); + +if (has_to) { + saddr->inet->has_to = true; + saddr->inet->to =strtol (has_to,NULL ,10 ); + } + saddr->inet->ipv4 = saddr->inet->has_ipv4 = has_ipv4; + saddr->inet->ipv6 = saddr->inet->has_ipv6 = has_ipv6; + +if (vs->ws_enabled) { + wsaddr->kind =SOCKET_ADDRESS_KIND_INET ; + wsaddr->inet =g_new0 (InetSocketAddress,1 ); + wsaddr->inet->host =g_strdup (saddr->inet->host); + wsaddr->inet->port =g_strdup (websocket); + +if (has_to) { + wsaddr->inet->has_to = true; + wsaddr->inet->to =strtol (has_to,NULL ,10 ); + } + wsaddr->inet->ipv4 = wsaddr->inet->has_ipv4 = has_ipv4; + wsaddr->inet->ipv6 = wsaddr->inet->has_ipv6 = has_ipv6; + } } -qemu_opt_set (sopts,"host" , host, &error_abort); -qemu_opt_set (wsopts,"host" , host, &error_abort); -qemu_opt_set (sopts,"port" , h+1 , &error_abort); -g_free (host); }else {error_setg (errp,"no vnc port specified" ); goto fail; } - has_to =qemu_opt_get (opts,"to" ); - has_ipv4 =qemu_opt_get_bool (opts,"ipv4" , false); - has_ipv6 =qemu_opt_get_bool (opts,"ipv6" , false); -if (has_to) { -qemu_opt_set (sopts,"to" , has_to, &error_abort); -qemu_opt_set (wsopts,"to" , has_to, &error_abort); - } -if (has_ipv4) { -qemu_opt_set (sopts,"ipv4" ,"on" , &error_abort); -qemu_opt_set (wsopts,"ipv4" ,"on" , &error_abort); - } -if (has_ipv6) { -qemu_opt_set (sopts,"ipv6" ,"on" , &error_abort); -qemu_opt_set (wsopts,"ipv6" ,"on" , &error_abort); - } - password =qemu_opt_get_bool (opts,"password" , false);if (password) {if (fips_get_state ()) {
@@ -3639,16 +3674,6 @@ void vnc_display_open(const char *id, Error **errp) } vs->connections_limit =qemu_opt_get_number (opts,"connections" ,32 ); - websocket =qemu_opt_get (opts,"websocket" ); -if (websocket) { - vs->ws_enabled = true; -qemu_opt_set (wsopts,"port" , websocket, &error_abort); -if (!qcrypto_hash_supports (QCRYPTO_HASH_ALG_SHA1 )) { -error_setg (errp,"SHA1 hash support is required for websockets" ); - goto fail; - } - } -#ifdef CONFIG_VNC_JPEG vs->lossy =qemu_opt_get_bool (opts,"lossy" , false);#endif
@@ -3682,7 +3707,7 @@ void vnc_display_open(const char *id, Error **errp) }#endif -if (vnc_display_setup_auth (vs, password, sasl, websocket, errp) <0 ) { +if (vnc_display_setup_auth (vs, password, sasl, vs->ws_enabled, errp) <0 ) { goto fail; }
@@ -3727,37 +3752,32 @@ void vnc_display_open(const char *id, Error **errp)int csock; vs->lsock =-1 ; vs->lwebsock =-1 ; -if (strncmp (vnc,"unix:" ,5 ) ==0 ) { - csock =unix_connect (vnc+5 , errp); - }else { - csock =inet_connect (vnc, errp); +if (vs->ws_enabled) { +error_setg (errp,"Cannot use websockets in reverse mode" ); + goto fail; } + csock =socket_connect (saddr, errp, +NULL ,NULL );if (csock <0 ) { goto fail; } + vs->is_unix = saddr->kind ==SOCKET_ADDRESS_KIND_UNIX ;vnc_connect (vs, csock, false, false); }else {/* listen for connects */ -if (strncmp (vnc,"unix:" ,5 ) ==0 ) { - vs->lsock =unix_listen (vnc+5 ,NULL ,0 , errp); -if (vs->lsock <0 ) { - goto fail; - } - vs->is_unix = true; - }else { - vs->lsock =inet_listen_opts (sopts,5900 , errp); -if (vs->lsock <0 ) { - goto fail; - } -if (vs->ws_enabled) { - vs->lwebsock =inet_listen_opts (wsopts,0 , errp); -if (vs->lwebsock <0 ) { -if (vs->lsock !=-1 ) { -close (vs->lsock); - vs->lsock =-1 ; - } - goto fail; + vs->lsock =socket_listen (saddr, errp); +if (vs->lsock <0 ) { + goto fail; + } + vs->is_unix = saddr->kind ==SOCKET_ADDRESS_KIND_UNIX ; +if (vs->ws_enabled) { + vs->lwebsock =socket_listen (wsaddr, errp); +if (vs->lwebsock <0 ) { +if (vs->lsock !=-1 ) { +close (vs->lsock); + vs->lsock =-1 ; } + goto fail; } } vs->enabled = true;
@@ -3767,13 +3787,14 @@ void vnc_display_open(const char *id, Error **errp) NULL, vs); } } -qemu_opts_del (sopts); -qemu_opts_del (wsopts); + +qapi_free_SocketAddress (saddr); +qapi_free_SocketAddress (wsaddr);return ; fail: -qemu_opts_del (sopts); -qemu_opts_del (wsopts); +qapi_free_SocketAddress (saddr); +qapi_free_SocketAddress (wsaddr); vs->enabled = false; vs->ws_enabled = false; }
Signature · 1 line
2.4.3
PATCH 16/46 ui: convert VNC server to use QIOChannelSocket
In reply to Daniel P. BerrangeThe minimal first step conversion to use QIOChannelSocket classes instead of directly using POSIX sockets API. This will later be extended to also cover the TLS, SASL and websockets code.
--- ui/vnc-auth-sasl.c | 57 +++-- ui/vnc-auth-vencrypt.c | 27 ++- ui/vnc-jobs.c | 12 +- ui/vnc-ws.c | 51 ++++- ui/vnc-ws.h | 8 +- ui/vnc.c | 559 ++++++++++++++++++++++++++----------------------- ui/vnc.h | 22 +- 7 files changed, 426 insertions(+), 310 deletions(-)
ui/vnc-auth-sasl.c +45 -12
@@ -62,7 +62,7 @@ long vnc_client_write_sasl(VncState *vs) (const char **)&vs->sasl.encoded, &vs->sasl.encodedLength);if (err !=SASL_OK ) -return vnc_client_io_error (vs,-1 ,EIO ); +return vnc_client_io_error (vs,-1 ,NULL ); vs->sasl.encodedOffset =0 ; }
@@ -86,7 +86,11 @@ long vnc_client_write_sasl(VncState *vs)* SASL encoded output */ if (vs->output.offset ==0 ) { -qemu_set_fd_handler (vs->csock, vnc_client_read,NULL , vs); +if (vs->ioc_tag) { +g_source_remove (vs->ioc_tag); + } + vs->ioc_tag =qio_channel_add_watch ( + vs->ioc,G_IO_IN , vnc_client_io, vs,NULL ); }return ret;
@@ -110,7 +114,7 @@ long vnc_client_read_sasl(VncState *vs) &decoded, &decodedLen);if (err !=SASL_OK ) -return vnc_client_io_error (vs,-1 , -EIO ); +return vnc_client_io_error (vs,-1 ,NULL );VNC_DEBUG ("Read SASL Encoded %p size %ld Decoded %p size %d\n" , encoded, ret, decoded, decodedLen);qio_buffer_reserve (&vs->input, decodedLen);
@@ -255,17 +259,17 @@ static int protocol_client_auth_sasl_step(VncState *vs, uint8_t *data, size_t levnc_read_when (vs, protocol_client_auth_sasl_step_len,4 ); }else {if (!vnc_auth_sasl_check_ssf (vs)) { -VNC_DEBUG ("Authentication rejected for weak SSF %d\n" , vs->csock); +VNC_DEBUG ("Authentication rejected for weak SSF %p\n" , vs->ioc); goto authreject; }/* Check username whitelist ACL */ if (vnc_auth_sasl_check_access (vs) <0 ) { -VNC_DEBUG ("Authentication rejected for ACL %d\n" , vs->csock); +VNC_DEBUG ("Authentication rejected for ACL %p\n" , vs->ioc); goto authreject; } -VNC_DEBUG ("Authentication successful %d\n" , vs->csock); +VNC_DEBUG ("Authentication successful %p\n" , vs->ioc);vnc_write_u32 (vs,0 );/* Accept auth */ /* * Delay writing in SSF encoded mode until pending output
@@ -383,17 +387,17 @@ static int protocol_client_auth_sasl_start(VncState *vs, uint8_t *data, size_t lvnc_read_when (vs, protocol_client_auth_sasl_step_len,4 ); }else {if (!vnc_auth_sasl_check_ssf (vs)) { -VNC_DEBUG ("Authentication rejected for weak SSF %d\n" , vs->csock); +VNC_DEBUG ("Authentication rejected for weak SSF %p\n" , vs->ioc); goto authreject; }/* Check username whitelist ACL */ if (vnc_auth_sasl_check_access (vs) <0 ) { -VNC_DEBUG ("Authentication rejected for ACL %d\n" , vs->csock); +VNC_DEBUG ("Authentication rejected for ACL %p\n" , vs->ioc); goto authreject; } -VNC_DEBUG ("Authentication successful %d\n" , vs->csock); +VNC_DEBUG ("Authentication successful %p\n" , vs->ioc);vnc_write_u32 (vs,0 );/* Accept auth */ start_client_init (vs); }
@@ -487,6 +491,32 @@ static int protocol_client_auth_sasl_mechname_len(VncState *vs, uint8_t *data, sreturn 0 ; } +static char * +vnc_socket_ip_addr_string (QIOChannelSocket *ioc, +bool local, +Error **errp) +{ +SocketAddress *addr; +char *ret; + +if (local) { + addr =qio_channel_socket_get_local_address (ioc, errp); + }else { + addr =qio_channel_socket_get_remote_address (ioc, errp); + } +if (!addr) { +return NULL ; + } + +if (addr->kind !=SOCKET_ADDRESS_KIND_INET ) { +error_setg (errp,"Not an inet socket type" ); +return NULL ; + } + ret =g_strdup_printf ("%s;%s" , addr->inet->host, addr->inet->port); +qapi_free_SocketAddress (addr); +return ret; +} +void start_auth_sasl (VncState *vs) {const char *mechlist =NULL ;
@@ -495,13 +525,16 @@ void start_auth_sasl(VncState *vs)char *localAddr, *remoteAddr;int mechlistlen; -VNC_DEBUG ("Initialize SASL auth %d\n" , vs->csock); +VNC_DEBUG ("Initialize SASL auth %p\n" , vs->ioc);/* Get local & remote client addresses in form IPADDR;PORT */ -if (!(localAddr =vnc_socket_local_addr ("%s;%s" , vs->csock))) + localAddr =vnc_socket_ip_addr_string (vs->sioc, true,NULL ); +if (!localAddr) { goto authabort; + } -if (!(remoteAddr =vnc_socket_remote_addr ("%s;%s" , vs->csock))) { + remoteAddr =vnc_socket_ip_addr_string (vs->sioc, false,NULL ); +if (!remoteAddr) {g_free (localAddr); goto authabort; }
ui/vnc-auth-vencrypt.c +22 -5
@@ -63,7 +63,9 @@ static void start_auth_vencrypt_subauth(VncState *vs) } } -static void vnc_tls_handshake_io (void *opaque); +static gboolean vnc_tls_handshake_io (QIOChannel *ioc, +GIOCondition condition, +void *opaque);static int vnc_start_vencrypt_handshake (VncState *vs) {
@@ -80,19 +82,31 @@ static int vnc_start_vencrypt_handshake(VncState *vs) goto error; }VNC_DEBUG ("Client verification passed, starting TLS I/O\n" ); -qemu_set_fd_handler (vs->csock, vnc_client_read, vnc_client_write, vs); +if (vs->ioc_tag) { +g_source_remove (vs->ioc_tag); + } + vs->ioc_tag =qio_channel_add_watch ( + vs->ioc,G_IO_IN |G_IO_OUT , vnc_client_io, vs,NULL );start_auth_vencrypt_subauth (vs);break ;case QCRYPTO_TLS_HANDSHAKE_RECVING :VNC_DEBUG ("Handshake interrupted (blocking read)\n" ); -qemu_set_fd_handler (vs->csock, vnc_tls_handshake_io,NULL , vs); +if (vs->ioc_tag) { +g_source_remove (vs->ioc_tag); + } + vs->ioc_tag =qio_channel_add_watch ( + vs->ioc,G_IO_IN , vnc_tls_handshake_io, vs,NULL );break ;case QCRYPTO_TLS_HANDSHAKE_SENDING :VNC_DEBUG ("Handshake interrupted (blocking write)\n" ); -qemu_set_fd_handler (vs->csock,NULL , vnc_tls_handshake_io, vs); +if (vs->ioc_tag) { +g_source_remove (vs->ioc_tag); + } + vs->ioc_tag =qio_channel_add_watch ( + vs->ioc,G_IO_OUT , vnc_tls_handshake_io, vs,NULL );break ; }
@@ -105,12 +119,15 @@ static int vnc_start_vencrypt_handshake(VncState *vs)return -1 ; } -static void vnc_tls_handshake_io (void *opaque) +static gboolean vnc_tls_handshake_io(QIOChannel *ioc G_GNUC_UNUSED, + GIOCondition condition G_GNUC_UNUSED, +void *opaque) {VncState *vs = (VncState *)opaque;VNC_DEBUG ("Handshake IO continue\n" );vnc_start_vencrypt_handshake (vs); +return TRUE; }
ui/vnc-jobs.c +6 -6
@@ -169,7 +169,7 @@ void vnc_jobs_consume_buffer(VncState *vs)vnc_write (vs, vs->jobs_buffer.buffer, vs->jobs_buffer.offset);qio_buffer_reset (&vs->jobs_buffer); } - flush = vs->csock !=-1 && vs->abort != true; + flush = vs->ioc !=NULL && vs->abort != true;vnc_unlock_output (vs);if (flush) {
@@ -194,7 +194,8 @@ static void vnc_async_encoding_start(VncState *orig, VncState *local) local->hextile = orig->hextile; local->zrle = orig->zrle; local->output = queue->buffer; - local->csock =-1 ;/* Don't do any network work on this thread */ + local->sioc =NULL ;/* Don't do any network work on this thread */ + local->ioc =NULL ;/* Don't do any network work on this thread */ qio_buffer_reset (&local->output); }
@@ -231,7 +232,7 @@ static int vnc_worker_thread_loop(VncJobQueue *queue) }vnc_lock_output (job->vs); -if (job->vs->csock ==-1 || job->vs->abort == true) { +if (job->vs->ioc ==NULL || job->vs->abort == true) {vnc_unlock_output (job->vs); goto disconnected; }
@@ -251,7 +252,7 @@ static int vnc_worker_thread_loop(VncJobQueue *queue) QLIST_FOREACH_SAFE(entry, &job->rectangles, next, tmp) {int n; -if (job->vs->csock ==-1 ) { +if (job->vs->ioc ==NULL ) {vnc_unlock_display (job->vs->vd);/* Copy persistent encoding data */ vnc_async_encoding_end (job->vs, &vs);
@@ -273,8 +274,7 @@ static int vnc_worker_thread_loop(VncJobQueue *queue) vs.output.buffer[saved_offset +1 ] = n_rectangles &0xFF ;vnc_lock_output (job->vs); - -if (job->vs->csock !=-1 ) { +if (job->vs->ioc !=NULL ) {qio_buffer_reserve (&job->vs->jobs_buffer, vs.output.offset);qio_buffer_append (&job->vs->jobs_buffer, vs.output.buffer, vs.output.offset);
ui/vnc-ws.c +41 -10
110 lines not on this page · raw message
ui/vnc-ws.h +6 -2
@@ -72,8 +72,12 @@ enum { WS_OPCODE_PONG = 0xA }; -void vncws_tls_handshake_io (void *opaque); -void vncws_handshake_read (void *opaque); +gboolean vncws_tls_handshake_io (QIOChannel *ioc, +GIOCondition condition, +void *opaque); +gboolean vncws_handshake_io (QIOChannel *ioc, +GIOCondition condition, +void *opaque);long vnc_client_write_ws (VncState *vs);long vnc_client_read_ws (VncState *vs);void vncws_process_handshake (VncState *vs,uint8_t *line,size_t size);
ui/vnc.c +293 -266
906 lines not on this page · raw message
ui/vnc.h +13 -9
@@ -35,6 +35,7 @@#include "qemu/bitmap.h" #include "crypto/tlssession.h" #include "io/buffer.h" +#include "io/channel-socket.h" #include <zlib.h> #include <stdbool.h>
@@ -145,8 +146,10 @@ struct VncDisplayint num_exclusive;int connections_limit;VncSharePolicy share_policy; -int lsock; -int lwebsock; +QIOChannelSocket *lsock; +guint lsock_tag; +QIOChannelSocket *lwebsock; +guint lwebsock_tag;bool ws_enabled;DisplaySurface *ds;DisplayChangeListener dcl;
@@ -248,7 +251,10 @@ struct VncJobstruct VncState { -int csock; +QIOChannelSocket *sioc;/* The underlying socket */ +QIOChannel *ioc;/* The channel currently used for I/O */ +guint ioc_tag; +gboolean disconnecting; DECLARE_BITMAP(dirty[VNC_MAX_HEIGHT], VNC_DIRTY_BITS);uint8_t **lossy_rect;/* Not an Array to avoid costly memcpy in
@@ -499,8 +505,9 @@ enum {*****************************************************************************/ /* Event loop functions */ -void vnc_client_read (void *opaque); -void vnc_client_write (void *opaque); +gboolean vnc_client_io (QIOChannel *ioc, +GIOCondition condition, +void *opaque);ssize_t vnc_client_read_buf (VncState *vs,uint8_t *data,size_t datalen);ssize_t vnc_client_write_buf (VncState *vs,const uint8_t *data,size_t datalen);
@@ -524,7 +531,7 @@ uint32_t read_u32(uint8_t *data, size_t offset);/* Protocol stage functions */ void vnc_client_error (VncState *vs); -ssize_t vnc_client_io_error (VncState *vs,ssize_t ret,int last_errno); +ssize_t vnc_client_io_error (VncState *vs,ssize_t ret,Error **errp);void start_client_init (VncState *vs);void start_auth_vnc (VncState *vs);
@@ -532,9 +539,6 @@ void start_auth_vnc(VncState *vs);/* Misc helpers */ -char *vnc_socket_local_addr (const char *format,int fd); -char *vnc_socket_remote_addr (const char *format,int fd); -static inline uint32_t vnc_has_feature (VncState *vs,int feature) {return (vs->features & (1 << feature)); }
Signature · 1 line
2.4.3
PATCH 17/46 ui: convert VNC server to use QIOChannelTLS
In reply to Daniel P. BerrangeSwitch VNC server over to using the QIOChannelTLS object for the TLS session. This removes all remaining VNC specific code for dealing with TLS handshakes.
--- ui/vnc-auth-sasl.c | 26 ++++++------ ui/vnc-auth-vencrypt.c | 106 ++++++++++++++----------------------------------- ui/vnc-ws.c | 95 +++++++++++++++++--------------------------- ui/vnc.c | 73 ++++------------------------------ ui/vnc.h | 5 +-- 5 files changed, 88 insertions(+), 217 deletions(-)
ui/vnc-auth-sasl.c +13 -13
@@ -521,7 +521,7 @@ void start_auth_sasl(VncState *vs) {const char *mechlist =NULL ;sasl_security_properties_t secprops; -int err; +int ret;char *localAddr, *remoteAddr;int mechlistlen;
@@ -539,7 +539,7 @@ void start_auth_sasl(VncState *vs) goto authabort; } - err = sasl_server_new("vnc", + ret = sasl_server_new("vnc", NULL, /* FQDN - just delegates to gethostname */ NULL, /* User realm */ localAddr,
@@ -551,9 +551,9 @@ void start_auth_sasl(VncState *vs)g_free (remoteAddr); localAddr = remoteAddr =NULL ; -if (err !=SASL_OK ) { +if (ret !=SASL_OK ) {VNC_DEBUG ("sasl context setup failed %d (%s)" , - err,sasl_errstring (err,NULL ,NULL )); + ret,sasl_errstring (ret,NULL ,NULL )); vs->sasl.conn =NULL ; goto authabort; }
@@ -577,10 +577,10 @@ void start_auth_sasl(VncState *vs) } ssf = keysize *CHAR_BIT ;/* tls key size is bytes, sasl wants bits */ - err =sasl_setprop (vs->sasl.conn,SASL_SSF_EXTERNAL , &ssf); -if (err !=SASL_OK ) { + ret =sasl_setprop (vs->sasl.conn,SASL_SSF_EXTERNAL , &ssf); +if (ret !=SASL_OK ) {VNC_DEBUG ("cannot set SASL external SSF %d (%s)\n" , - err,sasl_errstring (err,NULL ,NULL )); + ret,sasl_errstring (ret,NULL ,NULL ));sasl_dispose (&vs->sasl.conn); vs->sasl.conn =NULL ; goto authabort;
@@ -613,16 +613,16 @@ void start_auth_sasl(VncState *vs)SASL_SEC_NOANONYMOUS |SASL_SEC_NOPLAINTEXT ; } - err =sasl_setprop (vs->sasl.conn,SASL_SEC_PROPS , &secprops); -if (err !=SASL_OK ) { + ret =sasl_setprop (vs->sasl.conn,SASL_SEC_PROPS , &secprops); +if (ret !=SASL_OK ) {VNC_DEBUG ("cannot set SASL security props %d (%s)\n" , - err,sasl_errstring (err,NULL ,NULL )); + ret,sasl_errstring (ret,NULL ,NULL ));sasl_dispose (&vs->sasl.conn); vs->sasl.conn =NULL ; goto authabort; } - err = sasl_listmech(vs->sasl.conn, + ret = sasl_listmech(vs->sasl.conn, NULL, /* Don't need to set user */ "", /* Prefix */ ",", /* Separator */
@@ -630,9 +630,9 @@ void start_auth_sasl(VncState *vs) &mechlist,NULL , NULL); -if (err !=SASL_OK ) { +if (ret !=SASL_OK ) {VNC_DEBUG ("cannot list SASL mechanisms %d (%s)\n" , - err,sasl_errdetail (vs->sasl.conn)); + ret,sasl_errdetail (vs->sasl.conn));sasl_dispose (&vs->sasl.conn); vs->sasl.conn =NULL ; goto authabort;
ui/vnc-auth-vencrypt.c +30 -76
134 lines not on this page · raw message
ui/vnc-ws.c +36 -59
119 lines not on this page · raw message
ui/vnc.c +7 -66
109 lines not on this page · raw message
ui/vnc.h +2 -3
@@ -36,6 +36,7 @@#include "crypto/tlssession.h" #include "io/buffer.h" #include "io/channel-socket.h" +#include "io/channel-tls.h" #include <zlib.h> #include <stdbool.h>
@@ -281,7 +282,7 @@ struct VncStateint auth;int subauth;/* Used by VeNCrypt */ char challenge[VNC_AUTH_CHALLENGE_SIZE ]; -QCryptoTLSSession *tls; +QCryptoTLSSession *tls;/* Borrowed pointer from channel, don't free */ #ifdef CONFIG_VNC_SASL VncStateSASL sasl;#endif
@@ -511,8 +512,6 @@ gboolean vnc_client_io(QIOChannel *ioc,ssize_t vnc_client_read_buf (VncState *vs,uint8_t *data,size_t datalen);ssize_t vnc_client_write_buf (VncState *vs,const uint8_t *data,size_t datalen); -ssize_t vnc_tls_pull (char *buf,size_t len,void *opaque); -ssize_t vnc_tls_push (const char *buf,size_t len,void *opaque);/* Protocol I/O functions */ void vnc_write (VncState *vs,const void *data,size_t len);
Signature · 1 line
2.4.3
PATCH 18/46 ui: convert VNC server to use QIOChannelWebsock
In reply to Daniel P. BerrangeRemove custom websock handling code from the VNC server and use the QIOChannelWebsock class instead.
--- ui/vnc-ws.c | 328 +++++------------------------------------------------------- ui/vnc-ws.h | 63 ------------ ui/vnc.c | 25 +---- ui/vnc.h | 4 - 4 files changed, 30 insertions(+), 390 deletions(-)
ui/vnc-ws.c +26 -302
@@ -19,10 +19,7 @@*/ #include "vnc.h" -#include "qemu/main-loop.h" -#include "crypto/hash.h" - -static void vncws_handshake_read (VncState *vs); +#include "io/channel-websock.h" static void vncws_tls_handshake_done(Object *source, Error *err,
@@ -34,6 +31,7 @@ static void vncws_tls_handshake_done(Object *source,VNC_DEBUG ("Handshake failed %s\n" ,error_get_pretty (err));vnc_client_error (vs); }else { +VNC_DEBUG ("TLS handshake complete, starting websocket handshake\n" ); vs->ioc_tag =qio_channel_add_watch (QIO_CHANNEL (vs->ioc),G_IO_IN , vncws_handshake_io, vs,NULL ); }
@@ -79,38 +77,21 @@ gboolean vncws_tls_handshake_io(QIOChannel *ioc G_GNUC_UNUSED,return TRUE; } -static void vncws_handshake_read (VncState *vs) -{ -uint8_t *handshake_end; -long ret; -/* Typical HTTP headers from novnc are 512 bytes, so limiting -* total header size to 4096 is easily enough. */ -size_t want =4096 - vs->ws_input.offset; -qio_buffer_reserve (&vs->ws_input, want); - ret =vnc_client_read_buf (vs,qio_buffer_end (&vs->ws_input), want); -if (!ret) { -if (vs->disconnecting) { -vnc_disconnect_finish (vs); - } -return ; - } - vs->ws_input.offset += ret; +static void vncws_handshake_done (Object *source, +Error *err, +gpointer user_data) +{ +VncState *vs = user_data; - handshake_end = (uint8_t *)g_strstr_len ((char *)vs->ws_input.buffer, - vs->ws_input.offset,WS_HANDSHAKE_END ); -if (handshake_end) { -if (vs->ioc_tag) { -g_source_remove (vs->ioc_tag); - } +if (err) { +VNC_DEBUG ("Websock handshake failed %s\n" ,error_get_pretty (err)); +vnc_client_error (vs); + }else { +VNC_DEBUG ("Websock handshake complete, starting VNC protocol\n" ); +vnc_init_state (vs); vs->ioc_tag =qio_channel_add_watch ( vs->ioc,G_IO_IN , vnc_client_io, vs,NULL ); -vncws_process_handshake (vs, vs->ws_input.buffer, vs->ws_input.offset); -qio_buffer_advance (&vs->ws_input, handshake_end - vs->ws_input.buffer + -strlen (WS_HANDSHAKE_END )); - }else if (vs->ws_input.offset >=4096 ) { -VNC_DEBUG ("End of headers not found in first 4096 bytes\n" ); -vnc_client_error (vs); } }
@@ -120,280 +101,23 @@ gboolean vncws_handshake_io(QIOChannel *ioc G_GNUC_UNUSED, void *opaque) {VncState *vs = opaque; -vncws_handshake_read (vs); -return TRUE; -} - -long vnc_client_read_ws (VncState *vs) -{ -int ret, err; -uint8_t *payload; -size_t payload_size, header_size; -VNC_DEBUG ("Read websocket %p size %zd offset %zd\n" , vs->ws_input.buffer, - vs->ws_input.capacity, vs->ws_input.offset); -qio_buffer_reserve (&vs->ws_input,4096 ); - ret =vnc_client_read_buf (vs,qio_buffer_end (&vs->ws_input),4096 ); -if (!ret) { -return 0 ; - } - vs->ws_input.offset += ret; - - ret =0 ; -/* consume as much of ws_input buffer as possible */ -do { -if (vs->ws_payload_remain ==0 ) { - err =vncws_decode_frame_header (&vs->ws_input, - &header_size, - &vs->ws_payload_remain, - &vs->ws_payload_mask); -if (err <=0 ) { -return err; - } - -qio_buffer_advance (&vs->ws_input, header_size); - } -if (vs->ws_payload_remain !=0 ) { - err =vncws_decode_frame_payload (&vs->ws_input, - &vs->ws_payload_remain, - &vs->ws_payload_mask, - &payload, - &payload_size); -if (err <0 ) { -return err; - } -if (err ==0 ) { -return ret; - } - ret += err; - -qio_buffer_reserve (&vs->input, payload_size); -qio_buffer_append (&vs->input, payload, payload_size); - -qio_buffer_advance (&vs->ws_input, payload_size); - } - }while (vs->ws_input.offset >0 ); - -return ret; -} - -long vnc_client_write_ws (VncState *vs) -{ -long ret; -VNC_DEBUG ("Write WS: Pending output %p size %zd offset %zd\n" , - vs->output.buffer, vs->output.capacity, vs->output.offset); -vncws_encode_frame (&vs->ws_output, vs->output.buffer, vs->output.offset); -qio_buffer_reset (&vs->output); - ret =vnc_client_write_buf (vs, vs->ws_output.buffer, vs->ws_output.offset); -if (!ret) { -return 0 ; - } - -qio_buffer_advance (&vs->ws_output, ret); - -if (vs->ws_output.offset ==0 ) { -if (vs->ioc_tag) { -g_source_remove (vs->ioc_tag); - } - vs->ioc_tag =qio_channel_add_watch ( - vs->ioc,G_IO_IN , vnc_client_io, vs,NULL ); - } - -return ret; -} - -static char *vncws_extract_handshake_entry (const char *handshake, -size_t handshake_len,const char *name) -{ -char *begin, *end, *ret =NULL ; -char *line =g_strdup_printf ("%s%s: " ,WS_HANDSHAKE_DELIM , name); - begin =g_strstr_len (handshake, handshake_len, line); -if (begin !=NULL ) { - begin +=strlen (line); - end =g_strstr_len (begin, handshake_len - (begin - handshake), -WS_HANDSHAKE_DELIM ); -if (end !=NULL ) { - ret =g_strndup (begin, end - begin); - } - } -g_free (line); -return ret; -} - -static void vncws_send_handshake_response (VncState *vs,const char * key) -{ -char combined_key[WS_CLIENT_KEY_LEN +WS_GUID_LEN +1 ]; -char *accept =NULL , *response =NULL ; -Error *err =NULL ; - -g_strlcpy (combined_key, key,WS_CLIENT_KEY_LEN +1 ); -g_strlcat (combined_key,WS_GUID ,WS_CLIENT_KEY_LEN +WS_GUID_LEN +1 ); - -/* hash and encode it */ -if (qcrypto_hash_base64 (QCRYPTO_HASH_ALG_SHA1 , - combined_key, -WS_CLIENT_KEY_LEN +WS_GUID_LEN , - &accept, - &err) <0 ) { -VNC_DEBUG ("Hashing Websocket combined key failed %s\n" , -error_get_pretty (err)); -error_free (err); -vnc_client_error (vs); -return ; - } - - response =g_strdup_printf (WS_HANDSHAKE , accept); -vnc_client_write_buf (vs, (const uint8_t *)response,strlen (response)); +QIOChannelWebsock *wioc; -g_free (accept); -g_free (response); - - vs->encode_ws =1 ; -vnc_init_state (vs); -} - -void vncws_process_handshake (VncState *vs,uint8_t *line,size_t size) -{ -char *protocols =vncws_extract_handshake_entry ((const char *)line, size, -"Sec-WebSocket-Protocol" ); -char *version =vncws_extract_handshake_entry ((const char *)line, size, -"Sec-WebSocket-Version" ); -char *key =vncws_extract_handshake_entry ((const char *)line, size, -"Sec-WebSocket-Key" ); - -if (protocols && version && key - &&g_strrstr (protocols,"binary" ) - && !strcmp (version,WS_SUPPORTED_VERSION ) - &&strlen (key) ==WS_CLIENT_KEY_LEN ) { -vncws_send_handshake_response (vs, key); - }else { -VNC_DEBUG ("Defective Websockets header or unsupported protocol\n" ); -vnc_client_error (vs); - } - -g_free (protocols); -g_free (version); -g_free (key); -} - -void vncws_encode_frame (QIOBuffer *output,const void *payload, -const size_t payload_size) -{ -size_t header_size =0 ; -unsigned char opcode =WS_OPCODE_BINARY_FRAME ; -union { -char buf[WS_HEAD_MAX_LEN ]; -WsHeader ws; - } header; - -if (!payload_size) { -return ; - } - - header.ws.b0 =0x80 | (opcode &0x0f ); -if (payload_size <=125 ) { - header.ws.b1 = (uint8_t )payload_size; - header_size =2 ; - }else if (payload_size <65536 ) { - header.ws.b1 =0x7e ; - header.ws.u.s16.l16 =cpu_to_be16 ((uint16_t )payload_size); - header_size =4 ; - }else { - header.ws.b1 =0x7f ; - header.ws.u.s64.l64 =cpu_to_be64 (payload_size); - header_size =10 ; - } - -qio_buffer_reserve (output, header_size + payload_size); -qio_buffer_append (output, header.buf, header_size); -qio_buffer_append (output, payload, payload_size); -} - -int vncws_decode_frame_header (QIOBuffer *input, -size_t *header_size, -size_t *payload_remain, -WsMask *payload_mask) -{ -unsigned char opcode =0 , fin =0 , has_mask =0 ; -size_t payload_len; -WsHeader *header = (WsHeader *)input->buffer; - -if (input->offset <WS_HEAD_MIN_LEN +4 ) { -/* header not complete */ -return 0 ; - } - - fin = (header->b0 &0x80 ) >>7 ; - opcode = header->b0 &0x0f ; - has_mask = (header->b1 &0x80 ) >>7 ; - payload_len = header->b1 &0x7f ; - -if (opcode ==WS_OPCODE_CLOSE ) { -/* disconnect */ -return -1 ; - } - -/* Websocket frame sanity check: -* * Websocket fragmentation is not supported. -* * All websockets frames sent by a client have to be masked. -* * Only binary encoding is supported. -*/ -if (!fin || !has_mask || opcode !=WS_OPCODE_BINARY_FRAME ) { -VNC_DEBUG ("Received faulty/unsupported Websocket frame\n" ); -return -2 ; +VNC_DEBUG ("Websocket negotiate starting\n" ); +if (vs->ioc_tag) { +g_source_remove (vs->ioc_tag); + vs->ioc_tag =0 ; } -if (payload_len <126 ) { - *payload_remain = payload_len; - *header_size =6 ; - *payload_mask = header->u.m; - }else if (payload_len ==126 && input->offset >=8 ) { - *payload_remain =be16_to_cpu (header->u.s16.l16); - *header_size =8 ; - *payload_mask = header->u.s16.m16; - }else if (payload_len ==127 && input->offset >=14 ) { - *payload_remain =be64_to_cpu (header->u.s64.l64); - *header_size =14 ; - *payload_mask = header->u.s64.m64; - }else { -/* header not complete */ -return 0 ; - } + wioc =qio_channel_websock_new_server (vs->ioc); -return 1 ; -} - -int vncws_decode_frame_payload (QIOBuffer *input, -size_t *payload_remain,WsMask *payload_mask, -uint8_t **payload,size_t *payload_size) -{ -size_t i; -uint32_t *payload32; - - *payload = input->buffer; -/* If we aren't at the end of the payload, then drop -* off the last bytes, so we're always multiple of 4 -* for purpose of unmasking, except at end of payload -*/ -if (input->offset < *payload_remain) { - *payload_size = input->offset - (input->offset %4 ); - }else { - *payload_size = *payload_remain; - } -if (*payload_size ==0 ) { -return 0 ; - } - *payload_remain -= *payload_size; +object_unref (OBJECT (vs->ioc)); + vs->ioc =QIO_CHANNEL (wioc); -/* unmask frame */ -/* process 1 frame (32 bit op) */ - payload32 = (uint32_t *)(*payload); -for (i =0 ; i < *payload_size /4 ; i++) { - payload32[i] ^= payload_mask->u; - } -/* process the remaining bytes (if any) */ -for (i *=4 ; i < *payload_size; i++) { - (*payload)[i] ^= payload_mask->c[i %4 ]; - } +qio_channel_websock_handshake (wioc, + vncws_handshake_done, + vs, +NULL ); -return 1 ; +return TRUE; }
ui/vnc-ws.h +0 -63
74 lines not on this page · raw message
ui/vnc.c +4 -21
@@ -1154,8 +1154,6 @@ void vnc_disconnect_finish(VncState *vs)qio_buffer_free (&vs->input);qio_buffer_free (&vs->output); -qio_buffer_free (&vs->ws_input); -qio_buffer_free (&vs->ws_output);qapi_free_VncClientInfo (vs->info);
@@ -1310,11 +1308,7 @@ static void vnc_client_write_locked(VncState *vs) } else#endif /* CONFIG_VNC_SASL */ { -if (vs->encode_ws) { -vnc_client_write_ws (vs); - }else { -vnc_client_write_plain (vs); - } +vnc_client_write_plain (vs); } }
@@ -1322,7 +1316,7 @@ static void vnc_client_write(VncState *vs) {vnc_lock_output (vs); -if (vs->output.offset || vs->ws_output.offset) { +if (vs->output.offset) {vnc_client_write_locked (vs); }else if (vs->ioc !=NULL ) {if (vs->ioc_tag) {
@@ -1409,18 +1403,7 @@ static void vnc_client_read(VncState *vs) ret =vnc_client_read_sasl (vs); else#endif /* CONFIG_VNC_SASL */ -if (vs->encode_ws) { - ret =vnc_client_read_ws (vs); -if (ret ==-1 ) { -vnc_disconnect_start (vs); -return ; - }else if (ret ==-2 ) { -vnc_client_error (vs); -return ; - } - }else { - ret =vnc_client_read_plain (vs); - } + ret =vnc_client_read_plain (vs);if (!ret) {if (vs->disconnecting) {vnc_disconnect_finish (vs);
@@ -1510,7 +1493,7 @@ void vnc_write_u8(VncState *vs, uint8_t value)void vnc_flush (VncState *vs) {vnc_lock_output (vs); -if (vs->ioc !=NULL && (vs->output.offset || vs->ws_output.offset)) { +if (vs->ioc !=NULL && vs->output.offset) {vnc_client_write_locked (vs); }vnc_unlock_output (vs);
ui/vnc.h +0 -4
@@ -293,10 +293,6 @@ struct VncStateQIOBuffer output;QIOBuffer input; -QIOBuffer ws_input; -QIOBuffer ws_output; -size_t ws_payload_remain; -WsMask ws_payload_mask;/* current output mode information */ VncWritePixels *write_pixels;PixelFormat client_pf;
Signature · 1 line
2.4.3
PATCH 19/46 char: remove fixed length filename allocation
In reply to Daniel P. BerrangeA variety of places were snprintf()ing into a fixed length filename buffer. Some of the buffers were stack allocated, while another was heap allocated with g_malloc(). Switch them all to heap allocated using g_strdup_printf() avoiding arbitrary length restrictions.
--- qemu-char.c | 84 ++++++++++++++++++++++++++++++------------------------------- 1 file changed, 42 insertions(+), 42 deletions(-)
qemu-char.c +42 -42
@@ -88,39 +88,36 @@#define READ_BUF_LEN 4096#define READ_RETRIES 10 -#define CHR_MAX_FILENAME_SIZE 256#define TCP_MAX_FDS 16/***********************************************************/ /* Socket address helpers */ -static int SocketAddress_to_str (char *dest,int max_len, -const char *prefix,SocketAddress *addr, -bool is_listen,bool is_telnet) +static char *SocketAddress_to_str (const char *prefix,SocketAddress *addr, +bool is_listen,bool is_telnet) {switch (addr->kind) {case SOCKET_ADDRESS_KIND_INET : -return snprintf (dest, max_len,"%s%s:%s:%s%s" , prefix, - is_telnet ?"telnet" :"tcp" , addr->inet->host, - addr->inet->port, is_listen ?",server" :"" ); +return g_strdup_printf ("%s%s:%s:%s%s" , prefix, + is_telnet ?"telnet" :"tcp" , addr->inet->host, + addr->inet->port, is_listen ?",server" :"" );break ;case SOCKET_ADDRESS_KIND_UNIX : -return snprintf (dest, max_len,"%sunix:%s%s" , prefix, - addr->q_unix->path, is_listen ?",server" :"" ); +return g_strdup_printf ("%sunix:%s%s" , prefix, + addr->q_unix->path, is_listen ?",server" :"" );break ;case SOCKET_ADDRESS_KIND_FD : -return snprintf (dest, max_len,"%sfd:%s%s" , prefix, addr->fd->str, - is_listen ?",server" :"" ); +return g_strdup_printf ("%sfd:%s%s" , prefix, addr->fd->str, + is_listen ?",server" :"" );break ;default :abort (); } } -static int sockaddr_to_str (char *dest,int max_len, -struct sockaddr_storage *ss,socklen_t ss_len, -struct sockaddr_storage *ps,socklen_t ps_len, -bool is_listen,bool is_telnet) +static char *sockaddr_to_str (struct sockaddr_storage *ss,socklen_t ss_len, +struct sockaddr_storage *ps,socklen_t ps_len, +bool is_listen,bool is_telnet) {char shost[NI_MAXHOST ], sserv[NI_MAXSERV ];char phost[NI_MAXHOST ], pserv[NI_MAXSERV ];
@@ -129,9 +126,9 @@ static int sockaddr_to_str(char *dest, int max_len,switch (ss->ss_family) {#ifndef _WIN32case AF_UNIX : -return snprintf (dest, max_len,"unix:%s%s" , - ((struct sockaddr_un *)(ss))->sun_path, - is_listen ?",server" :"" ); +return g_strdup_printf ("unix:%s%s" , + ((struct sockaddr_un *)(ss))->sun_path, + is_listen ?",server" :"" );#endif case AF_INET6 : left ="[" ;
@@ -142,14 +139,14 @@ static int sockaddr_to_str(char *dest, int max_len, sserv, sizeof(sserv), NI_NUMERICHOST | NI_NUMERICSERV);getnameinfo ((struct sockaddr *) ps, ps_len, phost,sizeof (phost), pserv,sizeof (pserv),NI_NUMERICHOST |NI_NUMERICSERV ); -return snprintf (dest, max_len,"%s:%s%s%s:%s%s <-> %s%s%s:%s" , - is_telnet ?"telnet" :"tcp" , - left, shost, right, sserv, - is_listen ?",server" :"" , - left, phost, right, pserv); +return g_strdup_printf ("%s:%s%s%s:%s%s <-> %s%s%s:%s" , + is_telnet ?"telnet" :"tcp" , + left, shost, right, sserv, + is_listen ?",server" :"" , + left, phost, right, pserv);default : -return snprintf (dest, max_len,"unknown" ); +return g_strdup_printf ("unknown" ); } }
@@ -1057,8 +1054,8 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)static CharDriverState *qemu_chr_open_pipe (ChardevHostdev *opts) {int fd_in, fd_out; -char filename_in[CHR_MAX_FILENAME_SIZE ]; -char filename_out[CHR_MAX_FILENAME_SIZE ]; +char *filename_in; +char *filename_out;const char *filename = opts->device;if (filename ==NULL ) {
@@ -1066,10 +1063,12 @@ static CharDriverState *qemu_chr_open_pipe(ChardevHostdev *opts)return NULL ; } -snprintf (filename_in,CHR_MAX_FILENAME_SIZE ,"%s.in" , filename); -snprintf (filename_out,CHR_MAX_FILENAME_SIZE ,"%s.out" , filename); + filename_in =g_strdup_printf ("%s.in" , filename); + filename_out =g_strdup_printf ("%s.out" , filename);TFR (fd_in =qemu_open (filename_in,O_RDWR |O_BINARY ));TFR (fd_out =qemu_open (filename_out,O_RDWR |O_BINARY )); +g_free (filename_in); +g_free (filename_out);if (fd_in <0 || fd_out <0 ) {if (fd_in >=0 )close (fd_in);
@@ -2061,7 +2060,7 @@ static int win_chr_pipe_init(CharDriverState *chr, const char *filename)OVERLAPPED ov;int ret;DWORD size; -char openname[CHR_MAX_FILENAME_SIZE ]; +char *openname; s->fpipe = TRUE;
@@ -2076,11 +2075,12 @@ static int win_chr_pipe_init(CharDriverState *chr, const char *filename) goto fail; } -snprintf (openname,sizeof (openname),"\\\\.\\pipe\\%s" , filename); + openname =g_strdup_printf ("\\\\.\\pipe\\%s" , filename); s->hcom =CreateNamedPipe (openname,PIPE_ACCESS_DUPLEX |FILE_FLAG_OVERLAPPED ,PIPE_TYPE_BYTE |PIPE_READMODE_BYTE |PIPE_WAIT ,MAXCONNECT ,NSENDBUF ,NRECVBUF ,NTIMEOUT ,NULL ); +g_free (openname);if (s->hcom ==INVALID_HANDLE_VALUE ) {fprintf (stderr,"Failed CreateNamedPipe (%lu)\n" ,GetLastError ()); s->hcom =NULL ;
@@ -2817,8 +2817,9 @@ static void tcp_chr_disconnect(CharDriverState *chr) s->chan =NULL ;closesocket (s->fd); s->fd =-1 ; -SocketAddress_to_str (chr->filename,CHR_MAX_FILENAME_SIZE , -"disconnected:" , s->addr, s->is_listen, s->is_telnet); +g_free (chr->filename); + chr->filename =SocketAddress_to_str ("disconnected:" , s->addr, + s->is_listen, s->is_telnet);qemu_chr_be_event (chr,CHR_EVENT_CLOSED );if (s->reconnect_time) {qemu_chr_socket_restart_timer (chr);
@@ -2893,16 +2894,16 @@ static void tcp_chr_connect(void *opaque)socklen_t ss_len =sizeof (ss), ps_len =sizeof (ps);memset (&ss,0 , ss_len); +g_free (chr->filename);if (getsockname (s->fd, (struct sockaddr *) &ss, &ss_len) !=0 ) { -snprintf (chr->filename,CHR_MAX_FILENAME_SIZE , -"Error in getsockname: %s\n" ,strerror (errno)); + chr->filename =g_strdup_printf ("Error in getsockname: %s\n" , +strerror (errno)); }else if (getpeername (s->fd, (struct sockaddr *) &ps, &ps_len) !=0 ) { -snprintf (chr->filename,CHR_MAX_FILENAME_SIZE , -"Error in getpeername: %s\n" ,strerror (errno)); + chr->filename =g_strdup_printf ("Error in getpeername: %s\n" , +strerror (errno)); }else { -sockaddr_to_str (chr->filename,CHR_MAX_FILENAME_SIZE , - &ss, ss_len, &ps, ps_len, - s->is_listen, s->is_telnet); + chr->filename =sockaddr_to_str (&ss, ss_len, &ps, ps_len, + s->is_listen, s->is_telnet); } s->connected =1 ;
@@ -4144,9 +4145,8 @@ static CharDriverState *qmp_chardev_open_socket(ChardevSocket *sock,/* be isn't opened until we get a connection */ chr->explicit_be_open = true; - chr->filename =g_malloc (CHR_MAX_FILENAME_SIZE ); -SocketAddress_to_str (chr->filename,CHR_MAX_FILENAME_SIZE ,"disconnected:" , - addr, is_listen, is_telnet); + chr->filename =SocketAddress_to_str ("disconnected:" , + addr, is_listen, is_telnet);if (is_listen) {if (is_telnet) {
Signature · 1 line
2.4.3
PATCH 20/46 char: convert from GIOChannel to QIOChannel
In reply to Daniel P. BerrangeIn preparation for introducing TLS support to the TCP chardev backend, convert existing chardev code from using GIOChannel to QIOChannel. This simplifies the chardev code by removing most of the OS platform conditional code for dealing with file descriptor passing.
--- qemu-char.c | 646 +++++++++++++++++++++++------------------------------------- 1 file changed, 247 insertions(+), 399 deletions(-)
qemu-char.c +247 -399
@@ -32,6 +32,8 @@#include "qapi/qmp-input-visitor.h" #include "qapi/qmp-output-visitor.h" #include "qapi-visit.h" +#include "io/channel-socket.h" +#include "io/channel-file.h" #include <unistd.h> #include <fcntl.h>
@@ -756,7 +758,7 @@ typedef struct IOWatchPoll {GSource parent; -GIOChannel *channel; +QIOChannel *ioc;GSource *src;IOCanReadHandler *fd_can_read;
@@ -779,8 +781,8 @@ static gboolean io_watch_poll_prepare(GSource *source, gint *timeout_) }if (now_active) { - iwp->src =g_io_create_watch (iwp->channel, -G_IO_IN |G_IO_ERR |G_IO_HUP |G_IO_NVAL ); + iwp->src =qio_channel_create_watch ( + iwp->ioc,G_IO_IN |G_IO_ERR |G_IO_HUP |G_IO_NVAL );g_source_set_callback (iwp->src, iwp->fd_read, iwp->opaque,NULL );g_source_attach (iwp->src,NULL ); }else {
@@ -826,9 +828,9 @@ static GSourceFuncs io_watch_poll_funcs = { };/* Can only be used for read */ -static guint io_add_watch_poll (GIOChannel *channel, +static guint io_add_watch_poll (QIOChannel *ioc,IOCanReadHandler *fd_can_read, -GIOFunc fd_read, +QIOChannelFunc fd_read,gpointer user_data) {IOWatchPoll *iwp;
@@ -837,7 +839,7 @@ static guint io_add_watch_poll(GIOChannel *channel, iwp = (IOWatchPoll *)g_source_new (&io_watch_poll_funcs,sizeof (IOWatchPoll)); iwp->fd_can_read = fd_can_read; iwp->opaque = user_data; - iwp->channel = channel; + iwp->ioc = ioc; iwp->fd_read = (GSourceFunc ) fd_read; iwp->src =NULL ;
@@ -873,79 +875,53 @@ static void remove_fd_in_watch(CharDriverState *chr) } } -#ifndef _WIN32 -static GIOChannel *io_channel_from_fd (int fd) -{ -GIOChannel *chan; - -if (fd ==-1 ) { -return NULL ; - } - chan =g_io_channel_unix_new (fd); - -g_io_channel_set_encoding (chan,NULL ,NULL ); -g_io_channel_set_buffered (chan, FALSE); - -return chan; -} -#endif - -static GIOChannel *io_channel_from_socket (int fd) +static int io_channel_send_full (QIOChannel *ioc, +const void *buf,size_t len, +int *fds,size_t nfds) { -GIOChannel *chan; +size_t offset =0 ; -if (fd ==-1 ) { -return NULL ; - } +while (offset < len) { +ssize_t ret =0 ; +struct iovec iov = { .iov_base = (char *)buf + offset, + .iov_len = len - offset }; + + ret =qio_channel_writev_full ( + ioc, &iov,1 , + fds, nfds,NULL ); +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { + errno =EAGAIN ; +return -1 ; + } -#ifdef _WIN32 - chan =g_io_channel_win32_new_socket (fd); -#else - chan =g_io_channel_unix_new (fd); -#endif +if (ret >0 ) { + offset += ret; + } +if (ret <0 ) { +if (offset) { +return offset; + } -g_io_channel_set_encoding (chan,NULL ,NULL ); -g_io_channel_set_buffered (chan, FALSE); + errno =EINVAL ; +return -1 ; + } + } -return chan; +return offset; } -static int io_channel_send (GIOChannel *fd,const void *buf,size_t len) -{ -size_t offset =0 ; -GIOStatus status =G_IO_STATUS_NORMAL ; - -while (offset < len && status ==G_IO_STATUS_NORMAL ) { -gsize bytes_written =0 ; - status =g_io_channel_write_chars (fd, buf + offset, len - offset, - &bytes_written,NULL ); - offset += bytes_written; - } - -if (offset >0 ) { -return offset; - } -switch (status) { -case G_IO_STATUS_NORMAL : -g_assert (len ==0 ); -return 0 ; -case G_IO_STATUS_AGAIN : - errno =EAGAIN ; -return -1 ; -default : -break ; - } - errno =EINVAL ; -return -1 ; +static int io_channel_send (QIOChannel *ioc,const void *buf,size_t len) +{ +return io_channel_send_full (ioc, buf, len,NULL ,0 ); }#ifndef _WIN32typedef struct FDCharDriver {CharDriverState *chr; -GIOChannel *fd_in, *fd_out; +QIOChannel *ioc_in, *ioc_out;int max_size; }FDCharDriver ;
@@ -954,17 +930,16 @@ static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len) {FDCharDriver *s = chr->opaque; -return io_channel_send (s->fd_out, buf, len); +return io_channel_send (s->ioc_out, buf, len); } -static gboolean fd_chr_read (GIOChannel *chan,GIOCondition cond,void *opaque) +static gboolean fd_chr_read (QIOChannel *chan,GIOCondition cond,void *opaque) {CharDriverState *chr = opaque;FDCharDriver *s = chr->opaque;int len;uint8_t buf[READ_BUF_LEN ]; -GIOStatus status; -gsize bytes_read; +ssize_t ret; len =sizeof (buf);if (len > s->max_size) {
@@ -974,15 +949,15 @@ static gboolean fd_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)return TRUE; } - status =g_io_channel_read_chars (chan, (gchar *)buf, - len, &bytes_read,NULL ); -if (status ==G_IO_STATUS_EOF ) { + ret =qio_channel_read ( + chan, (gchar *)buf, len,NULL ); +if (ret ==0 ) {remove_fd_in_watch (chr);qemu_chr_be_event (chr,CHR_EVENT_CLOSED );return FALSE; } -if (status ==G_IO_STATUS_NORMAL ) { -qemu_chr_be_write (chr, buf, bytes_read); +if (ret >0 ) { +qemu_chr_be_write (chr, buf, ret); }return TRUE;
@@ -1000,7 +975,7 @@ static int fd_chr_read_poll(void *opaque)static GSource *fd_chr_add_watch (CharDriverState *chr,GIOCondition cond) {FDCharDriver *s = chr->opaque; -return g_io_create_watch (s->fd_out, cond); +return qio_channel_create_watch (s->ioc_out, cond); }static void fd_chr_update_read_handler (CharDriverState *chr)
@@ -1008,8 +983,9 @@ static void fd_chr_update_read_handler(CharDriverState *chr)FDCharDriver *s = chr->opaque;remove_fd_in_watch (chr); -if (s->fd_in) { - chr->fd_in_tag =io_add_watch_poll (s->fd_in, fd_chr_read_poll, +if (s->ioc_in) { + chr->fd_in_tag =io_add_watch_poll (s->ioc_in, + fd_chr_read_poll, fd_chr_read, chr); } }
@@ -1019,11 +995,11 @@ static void fd_chr_close(struct CharDriverState *chr)FDCharDriver *s = chr->opaque;remove_fd_in_watch (chr); -if (s->fd_in) { -g_io_channel_unref (s->fd_in); +if (s->ioc_in) { +object_unref (OBJECT (s->ioc_in)); } -if (s->fd_out) { -g_io_channel_unref (s->fd_out); +if (s->ioc_out) { +object_unref (OBJECT (s->ioc_out)); }g_free (s);
@@ -1038,8 +1014,8 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out) chr =qemu_chr_alloc (); s =g_malloc0 (sizeof (FDCharDriver)); - s->fd_in =io_channel_from_fd (fd_in); - s->fd_out =io_channel_from_fd (fd_out); + s->ioc_in =QIO_CHANNEL (qio_channel_file_new_fd (fd_in)); + s->ioc_out =QIO_CHANNEL (qio_channel_file_new_fd (fd_out));qemu_set_nonblock (fd_out); s->chr = chr; chr->opaque = s;
@@ -1174,7 +1150,7 @@ static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts)#define HAVE_CHARDEV_TTY 1 typedef struct { - GIOChannel *fd; + QIOChannel *ioc; int read_bytes; /* Protected by the CharDriverState chr_write_lock. */
@@ -1224,8 +1200,9 @@ static void pty_chr_update_read_handler_locked(CharDriverState *chr) {PtyCharDriver *s = chr->opaque;GPollFD pfd; +QIOChannelFile *fioc =QIO_CHANNEL_FILE (s->ioc); - pfd.fd =g_io_channel_unix_get_fd (s->fd); + pfd.fd = fioc->fd; pfd.events =G_IO_OUT ; pfd.revents =0 ;g_poll (&pfd,1 ,0 );
@@ -1255,7 +1232,7 @@ static int pty_chr_write(CharDriverState *chr, const uint8_t *buf, int len)return 0 ; } } -return io_channel_send (s->fd, buf, len); +return io_channel_send (s->ioc, buf, len); }static GSource *pty_chr_add_watch (CharDriverState *chr,GIOCondition cond)
@@ -1264,7 +1241,7 @@ static GSource *pty_chr_add_watch(CharDriverState *chr, GIOCondition cond)if (!s->connected) {return NULL ; } -return g_io_create_watch (s->fd, cond); +return qio_channel_create_watch (s->ioc, cond); }static int pty_chr_read_poll (void *opaque)
@@ -1276,13 +1253,13 @@ static int pty_chr_read_poll(void *opaque)return s->read_bytes; } -static gboolean pty_chr_read (GIOChannel *chan,GIOCondition cond,void *opaque) +static gboolean pty_chr_read (QIOChannel *chan,GIOCondition cond,void *opaque) {CharDriverState *chr = opaque;PtyCharDriver *s = chr->opaque; -gsize size, len; +gsize len;uint8_t buf[READ_BUF_LEN ]; -GIOStatus status; +ssize_t ret; len =sizeof (buf);if (len > s->read_bytes)
@@ -1290,13 +1267,13 @@ static gboolean pty_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)if (len ==0 ) {return TRUE; } - status =g_io_channel_read_chars (s->fd, (gchar *)buf, len, &size,NULL ); -if (status !=G_IO_STATUS_NORMAL ) { + ret =qio_channel_read (s->ioc, (char *)buf, len,NULL ); +if (ret <=0 ) {pty_chr_state (chr,0 );return FALSE; }else {pty_chr_state (chr,1 ); -qemu_chr_be_write (chr, buf, size); +qemu_chr_be_write (chr, buf, ret); }return TRUE; }
@@ -1338,7 +1315,8 @@ static void pty_chr_state(CharDriverState *chr, int connected) s->open_tag =g_idle_add (qemu_chr_be_generic_open_func, chr); }if (!chr->fd_in_tag) { - chr->fd_in_tag =io_add_watch_poll (s->fd, pty_chr_read_poll, + chr->fd_in_tag =io_add_watch_poll (s->ioc, + pty_chr_read_poll, pty_chr_read, chr); } }
@@ -1347,13 +1325,10 @@ static void pty_chr_state(CharDriverState *chr, int connected)static void pty_chr_close (struct CharDriverState *chr) {PtyCharDriver *s = chr->opaque; -int fd;qemu_mutex_lock (&chr->chr_write_lock);pty_chr_state (chr,0 ); - fd =g_io_channel_unix_get_fd (s->fd); -g_io_channel_unref (s->fd); -close (fd); +object_unref (OBJECT (s->ioc));if (s->timer_tag) {g_source_remove (s->timer_tag); s->timer_tag =0 ;
@@ -1396,7 +1371,7 @@ static CharDriverState *qemu_chr_open_pty(const char *id, chr->chr_add_watch = pty_chr_add_watch; chr->explicit_be_open = true; - s->fd =io_channel_from_fd (master_fd); + s->ioc =QIO_CHANNEL (qio_channel_file_new_fd (master_fd)); s->timer_tag =0 ;return chr;
@@ -1520,12 +1495,13 @@ static void tty_serial_init(int fd, int speed,static int tty_serial_ioctl (CharDriverState *chr,int cmd,void *arg) {FDCharDriver *s = chr->opaque; +QIOChannelFile *fioc =QIO_CHANNEL_FILE (s->ioc_in);switch (cmd) {case CHR_IOCTL_SERIAL_SET_PARAMS : {QEMUSerialSetParams *ssp = arg; -tty_serial_init (g_io_channel_unix_get_fd (s->fd_in), +tty_serial_init (fioc->fd, ssp->speed, ssp->parity, ssp->data_bits, ssp->stop_bits); }
@@ -1534,7 +1510,7 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg) {int enable = *(int *)arg;if (enable) { -tcsendbreak (g_io_channel_unix_get_fd (s->fd_in),1 ); +tcsendbreak (fioc->fd,1 ); } }break ;
@@ -1542,7 +1518,7 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg) {int sarg =0 ;int *targ = (int *)arg; -ioctl (g_io_channel_unix_get_fd (s->fd_in),TIOCMGET , &sarg); +ioctl (fioc->fd,TIOCMGET , &sarg); *targ =0 ;if (sarg &TIOCM_CTS ) *targ |=CHR_TIOCM_CTS ;
@@ -1562,7 +1538,7 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg) {int sarg = *(int *)arg;int targ =0 ; -ioctl (g_io_channel_unix_get_fd (s->fd_in),TIOCMGET , &targ); +ioctl (fioc->fd,TIOCMGET , &targ); targ &= ~(CHR_TIOCM_CTS |CHR_TIOCM_CAR |CHR_TIOCM_DSR |CHR_TIOCM_RI |CHR_TIOCM_DTR |CHR_TIOCM_RTS );if (sarg &CHR_TIOCM_CTS )
@@ -1577,7 +1553,7 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg) targ |=TIOCM_DTR ;if (sarg &CHR_TIOCM_RTS ) targ |=TIOCM_RTS ; -ioctl (g_io_channel_unix_get_fd (s->fd_in),TIOCMSET , &targ); +ioctl (fioc->fd,TIOCMSET , &targ); }break ;default :
@@ -1588,18 +1564,7 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)static void qemu_chr_close_tty (CharDriverState *chr) { -FDCharDriver *s = chr->opaque; -int fd =-1 ; - -if (s) { - fd =g_io_channel_unix_get_fd (s->fd_in); - } -fd_chr_close (chr); - -if (fd >=0 ) { -close (fd); - } }static CharDriverState *qemu_chr_open_tty_fd (int fd)
@@ -2361,8 +2326,7 @@ static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts)/* UDP Net console */ typedef struct { - int fd; - GIOChannel *chan; + QIOChannel *ioc; uint8_t buf[READ_BUF_LEN]; int bufcnt; int bufptr;
@@ -2373,17 +2337,9 @@ typedef struct {static int udp_chr_write (CharDriverState *chr,const uint8_t *buf,int len) {NetCharDriver *s = chr->opaque; -gsize bytes_written; -GIOStatus status; - - status =g_io_channel_write_chars (s->chan, (const gchar *)buf, len, &bytes_written,NULL ); -if (status ==G_IO_STATUS_EOF ) { -return 0 ; - }else if (status !=G_IO_STATUS_NORMAL ) { -return -1 ; - } -return bytes_written; +return qio_channel_write ( + s->ioc, (const char *)buf, len,NULL ); }static int udp_chr_read_poll (void *opaque)
@@ -2404,24 +2360,22 @@ static int udp_chr_read_poll(void *opaque)return s->max_size; } -static gboolean udp_chr_read (GIOChannel *chan,GIOCondition cond,void *opaque) +static gboolean udp_chr_read (QIOChannel *chan,GIOCondition cond,void *opaque) {CharDriverState *chr = opaque;NetCharDriver *s = chr->opaque; -gsize bytes_read =0 ; -GIOStatus status; +ssize_t ret;if (s->max_size ==0 ) {return TRUE; } - status =g_io_channel_read_chars (s->chan, (gchar *)s->buf,sizeof (s->buf), - &bytes_read,NULL ); - s->bufcnt = bytes_read; - s->bufptr = s->bufcnt; -if (status !=G_IO_STATUS_NORMAL ) { + ret =qio_channel_read ( + s->ioc, (char *)s->buf,sizeof (s->buf),NULL ); +if (ret <=0 ) {remove_fd_in_watch (chr);return FALSE; } + s->bufcnt = ret; s->bufptr =0 ;while (s->max_size >0 && s->bufptr < s->bufcnt) {
@@ -2438,8 +2392,9 @@ static void udp_chr_update_read_handler(CharDriverState *chr)NetCharDriver *s = chr->opaque;remove_fd_in_watch (chr); -if (s->chan) { - chr->fd_in_tag =io_add_watch_poll (s->chan, udp_chr_read_poll, +if (s->ioc) { + chr->fd_in_tag =io_add_watch_poll (s->ioc, + udp_chr_read_poll, udp_chr_read, chr); } }
@@ -2449,15 +2404,14 @@ static void udp_chr_close(CharDriverState *chr)NetCharDriver *s = chr->opaque;remove_fd_in_watch (chr); -if (s->chan) { -g_io_channel_unref (s->chan); -closesocket (s->fd); +if (s->ioc) { +object_unref (OBJECT (s->ioc)); }g_free (s);qemu_chr_be_event (chr,CHR_EVENT_CLOSED ); } -static CharDriverState *qemu_chr_open_udp_fd (int fd) +static CharDriverState *qemu_chr_open_udp (QIOChannelSocket *sioc) {CharDriverState *chr =NULL ;NetCharDriver *s =NULL ;
@@ -2465,8 +2419,7 @@ static CharDriverState *qemu_chr_open_udp_fd(int fd) chr =qemu_chr_alloc (); s =g_malloc0 (sizeof (NetCharDriver)); - s->fd = fd; - s->chan =io_channel_from_socket (s->fd); + s->ioc =QIO_CHANNEL (sioc); s->bufcnt =0 ; s->bufptr =0 ; chr->opaque = s;
@@ -2482,19 +2435,18 @@ static CharDriverState *qemu_chr_open_udp_fd(int fd)/* TCP Net console */ typedef struct { - - GIOChannel *chan, *listen_chan; + QIOChannel *ioc; + QIOChannelSocket *listen_ioc; guint listen_tag; - int fd, listen_fd; int connected; int max_size; int do_telnetopt; int do_nodelay; int is_unix; int *read_msgfds; - int read_msgfds_num; + size_t read_msgfds_num; int *write_msgfds; - int write_msgfds_num; + size_t write_msgfds_num; SocketAddress *addr; bool is_listen;
@@ -2528,68 +2480,25 @@ static void check_report_connect_error(CharDriverState *chr,qemu_chr_socket_restart_timer (chr); } -static gboolean tcp_chr_accept (GIOChannel *chan,GIOCondition cond,void *opaque); - -#ifndef _WIN32 -static int unix_send_msgfds (CharDriverState *chr,const uint8_t *buf,int len) -{ -TCPCharDriver *s = chr->opaque; -struct msghdr msgh; -struct iovec iov; -int r; - -size_t fd_size = s->write_msgfds_num *sizeof (int ); -char control[CMSG_SPACE (fd_size)]; -struct cmsghdr *cmsg; - -memset (&msgh,0 ,sizeof (msgh)); -memset (control,0 ,sizeof (control)); - -/* set the payload */ - iov.iov_base = (uint8_t *) buf; - iov.iov_len = len; - - msgh.msg_iov = &iov; - msgh.msg_iovlen =1 ; - - msgh.msg_control = control; - msgh.msg_controllen =sizeof (control); - - cmsg =CMSG_FIRSTHDR (&msgh); - - cmsg->cmsg_len =CMSG_LEN (fd_size); - cmsg->cmsg_level =SOL_SOCKET ; - cmsg->cmsg_type =SCM_RIGHTS ; -memcpy (CMSG_DATA (cmsg), s->write_msgfds, fd_size); - -do { - r =sendmsg (s->fd, &msgh,0 ); - }while (r <0 && errno ==EINTR ); - -/* free the written msgfds, no matter what */ -if (s->write_msgfds_num) { -g_free (s->write_msgfds); - s->write_msgfds =0 ; - s->write_msgfds_num =0 ; - } - -return r; -} -#endif +static gboolean tcp_chr_accept (QIOChannel *chan, +GIOCondition cond, +void *opaque);/* Called with chr_write_lock held. */ static int tcp_chr_write (CharDriverState *chr,const uint8_t *buf,int len) {TCPCharDriver *s = chr->opaque;if (s->connected) { -#ifndef _WIN32 -if (s->is_unix && s->write_msgfds_num) { -return unix_send_msgfds (chr, buf, len); - } else -#endif - { -return io_channel_send (s->chan, buf, len); +int ret =io_channel_send (s->ioc, buf, len); + +/* free the written msgfds, no matter what */ +if (s->write_msgfds_num) { +g_free (s->write_msgfds); + s->write_msgfds =0 ; + s->write_msgfds_num =0 ; } + +return ret; }else {/* XXX: indicate an error ? */ return len;
@@ -2700,107 +2609,53 @@ static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num)return 0 ; } -#ifndef _WIN32 -static void unix_process_msgfd (CharDriverState *chr,struct msghdr *msg) +static ssize_t tcp_chr_recv (CharDriverState *chr,char *buf,size_t len) {TCPCharDriver *s = chr->opaque; -struct cmsghdr *cmsg; +struct iovec iov = { .iov_base = buf, .iov_len = len }; +int ret; +size_t i; -for (cmsg =CMSG_FIRSTHDR (msg); cmsg; cmsg =CMSG_NXTHDR (msg, cmsg)) { -int fd_size, i; +/* close and clean read_msgfds */ +for (i =0 ; i < s->read_msgfds_num; i++) { +close (s->read_msgfds[i]); + } -if (cmsg->cmsg_len <CMSG_LEN (sizeof (int )) || - cmsg->cmsg_level !=SOL_SOCKET || - cmsg->cmsg_type !=SCM_RIGHTS ) { -continue ; - } +if (s->read_msgfds_num) { +g_free (s->read_msgfds); + } - fd_size = cmsg->cmsg_len -CMSG_LEN (0 ); +if (qio_channel_has_feature (s->ioc,QIO_CHANNEL_FEATURE_FD_PASS )) { + ret =qio_channel_readv_full (s->ioc, &iov,1 , + &s->read_msgfds, &s->read_msgfds_num, +NULL ); + }else { + ret =qio_channel_readv_full (s->ioc, &iov,1 , +NULL ,NULL , +NULL ); + } -if (!fd_size) { +for (i =0 ; i < s->read_msgfds_num; i++) { +int fd = s->read_msgfds[i]; +if (fd <0 ) {continue ; } -/* close and clean read_msgfds */ -for (i =0 ; i < s->read_msgfds_num; i++) { -close (s->read_msgfds[i]); - } - -if (s->read_msgfds_num) { -g_free (s->read_msgfds); - } - - s->read_msgfds_num = fd_size /sizeof (int ); - s->read_msgfds =g_malloc (fd_size); -memcpy (s->read_msgfds,CMSG_DATA (cmsg), fd_size); - -for (i =0 ; i < s->read_msgfds_num; i++) { -int fd = s->read_msgfds[i]; -if (fd <0 ) { -continue ; - } - -/* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */ -qemu_set_block (fd); - -#ifndef MSG_CMSG_CLOEXEC -qemu_set_cloexec (fd); -#endif - } - } -} - -static ssize_t tcp_chr_recv (CharDriverState *chr,char *buf,size_t len) -{ -TCPCharDriver *s = chr->opaque; -struct msghdr msg = {NULL , }; -struct iovec iov[1 ]; -union { -struct cmsghdr cmsg; -char control[CMSG_SPACE (sizeof (int ) *TCP_MAX_FDS )]; - } msg_control; -int flags =0 ; -ssize_t ret; - - iov[0 ].iov_base = buf; - iov[0 ].iov_len = len; - - msg.msg_iov = iov; - msg.msg_iovlen =1 ; - msg.msg_control = &msg_control; - msg.msg_controllen =sizeof (msg_control); +/* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */ +qemu_set_block (fd); -#ifdef MSG_CMSG_CLOEXEC - flags |=MSG_CMSG_CLOEXEC ; +#ifndef MSG_CMSG_CLOEXEC +qemu_set_cloexec (fd);#endif -do { - ret =recvmsg (s->fd, &msg, flags); - }while (ret ==-1 && errno ==EINTR ); - -if (ret >0 && s->is_unix) { -unix_process_msgfd (chr, &msg); }return ret; } -#else -static ssize_t tcp_chr_recv (CharDriverState *chr,char *buf,size_t len) -{ -TCPCharDriver *s = chr->opaque; -ssize_t ret; - -do { - ret =qemu_recv (s->fd, buf, len,0 ); - }while (ret ==-1 &&socket_error () ==EINTR ); - -return ret; -} -#endif static GSource *tcp_chr_add_watch (CharDriverState *chr,GIOCondition cond) {TCPCharDriver *s = chr->opaque; -return g_io_create_watch (s->chan, cond); +return qio_channel_create_watch (s->ioc, cond); }static void tcp_chr_disconnect (CharDriverState *chr)
@@ -2808,15 +2663,13 @@ static void tcp_chr_disconnect(CharDriverState *chr)TCPCharDriver *s = chr->opaque; s->connected =0 ; -if (s->listen_chan) { - s->listen_tag =g_io_add_watch (s->listen_chan,G_IO_IN , - tcp_chr_accept, chr); +if (s->listen_ioc) { + s->listen_tag =qio_channel_add_watch ( +QIO_CHANNEL (s->listen_ioc),G_IO_IN , tcp_chr_accept, chr,NULL ); }remove_fd_in_watch (chr); -g_io_channel_unref (s->chan); - s->chan =NULL ; -closesocket (s->fd); - s->fd =-1 ; +object_unref (OBJECT (s->ioc)); + s->ioc =NULL ;g_free (chr->filename); chr->filename =SocketAddress_to_str ("disconnected:" , s->addr, s->is_listen, s->is_telnet);
@@ -2826,7 +2679,7 @@ static void tcp_chr_disconnect(CharDriverState *chr) } } -static gboolean tcp_chr_read (GIOChannel *chan,GIOCondition cond,void *opaque) +static gboolean tcp_chr_read (QIOChannel *chan,GIOCondition cond,void *opaque) {CharDriverState *chr = opaque;TCPCharDriver *s = chr->opaque;
@@ -2840,9 +2693,7 @@ static gboolean tcp_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)if (len > s->max_size) len = s->max_size; size =tcp_chr_recv (chr, (void *)buf, len); -if (size ==0 || - (size <0 && -socket_error () !=EAGAIN &&socket_error () !=EWOULDBLOCK )) { +if (size ==0 || size ==-1 ) {/* connection closed */ tcp_chr_disconnect (chr); }else if (size >0 ) {
@@ -2890,25 +2741,17 @@ static void tcp_chr_connect(void *opaque) {CharDriverState *chr = opaque;TCPCharDriver *s = chr->opaque; -struct sockaddr_storage ss, ps; -socklen_t ss_len =sizeof (ss), ps_len =sizeof (ps); +QIOChannelSocket *sioc =QIO_CHANNEL_SOCKET (s->ioc); -memset (&ss,0 , ss_len);g_free (chr->filename); -if (getsockname (s->fd, (struct sockaddr *) &ss, &ss_len) !=0 ) { - chr->filename =g_strdup_printf ("Error in getsockname: %s\n" , -strerror (errno)); - }else if (getpeername (s->fd, (struct sockaddr *) &ps, &ps_len) !=0 ) { - chr->filename =g_strdup_printf ("Error in getpeername: %s\n" , -strerror (errno)); - }else { - chr->filename =sockaddr_to_str (&ss, ss_len, &ps, ps_len, - s->is_listen, s->is_telnet); - } + chr->filename =sockaddr_to_str (&sioc->localAddr, sioc->localAddrLen, + &sioc->remoteAddr, sioc->remoteAddrLen, + s->is_listen, s->is_telnet); s->connected =1 ; -if (s->chan) { - chr->fd_in_tag =io_add_watch_poll (s->chan, tcp_chr_read_poll, +if (s->ioc) { + chr->fd_in_tag =io_add_watch_poll (s->ioc, + tcp_chr_read_poll, tcp_chr_read, chr); }qemu_chr_be_generic_open (chr);
@@ -2919,38 +2762,42 @@ static void tcp_chr_update_read_handler(CharDriverState *chr)TCPCharDriver *s = chr->opaque;remove_fd_in_watch (chr); -if (s->chan) { - chr->fd_in_tag =io_add_watch_poll (s->chan, tcp_chr_read_poll, +if (s->ioc) { + chr->fd_in_tag =io_add_watch_poll (s->ioc, + tcp_chr_read_poll, tcp_chr_read, chr); } }#define IACSET (x,a,b,c) x[0] = a; x[1] = b; x[2] = c; -static void tcp_chr_telnet_init (int fd) +static void tcp_chr_telnet_init (QIOChannel *ioc) {char buf[3 ];/* Send the telnet negotion to put telnet in binary, no echo, single char mode */ IACSET (buf,0xff ,0xfb ,0x01 );/* IAC WILL ECHO */ -send (fd, (char *)buf,3 ,0 ); +qio_channel_write (ioc, buf,3 ,NULL );IACSET (buf,0xff ,0xfb ,0x03 );/* IAC WILL Suppress go ahead */ -send (fd, (char *)buf,3 ,0 ); +qio_channel_write (ioc, buf,3 ,NULL );IACSET (buf,0xff ,0xfb ,0x00 );/* IAC WILL Binary */ -send (fd, (char *)buf,3 ,0 ); +qio_channel_write (ioc, buf,3 ,NULL );IACSET (buf,0xff ,0xfd ,0x00 );/* IAC DO Binary */ -send (fd, (char *)buf,3 ,0 ); +qio_channel_write (ioc, buf,3 ,NULL ); } -static int tcp_chr_add_client (CharDriverState *chr,int fd) +static int tcp_chr_new_client (CharDriverState *chr,QIOChannelSocket *sioc) {TCPCharDriver *s = chr->opaque; -if (s->fd !=-1 ) +if (s->ioc !=NULL ) {return -1 ; + } -qemu_set_nonblock (fd); -if (s->do_nodelay) -socket_set_nodelay (fd); - s->fd = fd; - s->chan =io_channel_from_socket (fd); + s->ioc =QIO_CHANNEL (sioc); +object_ref (OBJECT (sioc)); + +qio_channel_set_blocking (s->ioc, false); +if (s->do_nodelay) { +qio_channel_socket_set_nodelay (sioc, true); + }if (s->listen_tag) {g_source_remove (s->listen_tag); s->listen_tag =0 ;
@@ -2960,41 +2807,42 @@ static int tcp_chr_add_client(CharDriverState *chr, int fd)return 0 ; } -static gboolean tcp_chr_accept (GIOChannel *channel,GIOCondition cond,void *opaque) + +static int tcp_chr_add_client (CharDriverState *chr,int fd) +{ +int ret; +QIOChannelSocket *sioc; + + sioc =qio_channel_socket_new_fd (fd,NULL ); +if (!sioc) { +return -1 ; + } + ret =tcp_chr_new_client (chr, sioc); +object_unref (OBJECT (sioc)); +return ret; +} + +static gboolean tcp_chr_accept (QIOChannel *channel, +GIOCondition cond, +void *opaque) {CharDriverState *chr = opaque;TCPCharDriver *s = chr->opaque; -struct sockaddr_in saddr; -#ifndef _WIN32 -struct sockaddr_un uaddr; -#endif -struct sockaddr *addr; -socklen_t len; -int fd; +QIOChannelSocket *sioc; -for (;;) { -#ifndef _WIN32 -if (s->is_unix) { - len =sizeof (uaddr); - addr = (struct sockaddr *)&uaddr; - } else -#endif - { - len =sizeof (saddr); - addr = (struct sockaddr *)&saddr; - } - fd =qemu_accept (s->listen_fd, addr, &len); -if (fd <0 && errno !=EINTR ) { - s->listen_tag =0 ; -return FALSE; - }else if (fd >=0 ) { -if (s->do_telnetopt) -tcp_chr_telnet_init (fd); -break ; - } + sioc =qio_channel_socket_accept (QIO_CHANNEL_SOCKET (channel), +NULL ); +if (!sioc) { +return TRUE; } -if (tcp_chr_add_client (chr, fd) <0 ) -close (fd); + +if (s->do_telnetopt) { +tcp_chr_telnet_init (QIO_CHANNEL (sioc)); + } + +tcp_chr_new_client (chr, sioc); + +object_unref (OBJECT (sioc));return TRUE; }
@@ -3009,22 +2857,16 @@ static void tcp_chr_close(CharDriverState *chr) s->reconnect_timer =0 ; }qapi_free_SocketAddress (s->addr); -if (s->fd >=0 ) { -remove_fd_in_watch (chr); -if (s->chan) { -g_io_channel_unref (s->chan); - } -closesocket (s->fd); +remove_fd_in_watch (chr); +if (s->ioc) { +object_unref (OBJECT (s->ioc)); } -if (s->listen_fd >=0 ) { -if (s->listen_tag) { -g_source_remove (s->listen_tag); - s->listen_tag =0 ; - } -if (s->listen_chan) { -g_io_channel_unref (s->listen_chan); - } -closesocket (s->listen_fd); +if (s->listen_tag) { +g_source_remove (s->listen_tag); + s->listen_tag =0 ; + } +if (s->listen_ioc) { +object_unref (OBJECT (s->listen_ioc)); }if (s->read_msgfds_num) {for (i =0 ; i < s->read_msgfds_num; i++) {
@@ -3039,57 +2881,63 @@ static void tcp_chr_close(CharDriverState *chr)qemu_chr_be_event (chr,CHR_EVENT_CLOSED ); } -static void qemu_chr_finish_socket_connection (CharDriverState *chr,int fd) +static void qemu_chr_finish_socket_connection (CharDriverState *chr, +QIOChannelSocket *sioc) {TCPCharDriver *s = chr->opaque;if (s->is_listen) { - s->listen_fd = fd; - s->listen_chan =io_channel_from_socket (s->listen_fd); - s->listen_tag =g_io_add_watch (s->listen_chan,G_IO_IN , - tcp_chr_accept, chr); + s->listen_ioc = sioc; + s->listen_tag =qio_channel_add_watch ( +QIO_CHANNEL (s->listen_ioc),G_IO_IN , tcp_chr_accept, chr,NULL ); }else { - s->connected =1 ; - s->fd = fd; -socket_set_nodelay (fd); - s->chan =io_channel_from_socket (s->fd); -tcp_chr_connect (chr); +tcp_chr_new_client (chr, sioc); +object_unref (OBJECT (sioc)); } } -static void qemu_chr_socket_connected (int fd,Error *err,void *opaque) +static void qemu_chr_socket_connected (Object *src,Error *err,void *opaque) { +QIOChannelSocket *sioc =QIO_CHANNEL_SOCKET (src);CharDriverState *chr = opaque;TCPCharDriver *s = chr->opaque; -if (fd <0 ) { +if (err) {check_report_connect_error (chr, err); +object_unref (src);return ; } s->connect_err_reported = false; -qemu_chr_finish_socket_connection (chr, fd); +qemu_chr_finish_socket_connection (chr, sioc); }static bool qemu_chr_open_socket_fd (CharDriverState *chr,Error **errp) {TCPCharDriver *s = chr->opaque; -int fd; +QIOChannelSocket *sioc =qio_channel_socket_new ();if (s->is_listen) { - fd =socket_listen (s->addr, errp); +if (qio_channel_socket_listen_sync (sioc, s->addr, errp) <0 ) { + goto fail; + } +qemu_chr_finish_socket_connection (chr, sioc); }else if (s->reconnect_time) { - fd =socket_connect (s->addr, errp, qemu_chr_socket_connected, chr); -return fd >=0 ; +qio_channel_socket_connect_async (sioc, s->addr, + qemu_chr_socket_connected, + chr,NULL ); }else { - fd =socket_connect (s->addr, errp,NULL ,NULL ); - } -if (fd <0 ) { -return false; +if (qio_channel_socket_connect_sync (sioc, s->addr, errp) <0 ) { + goto fail; + } +qemu_chr_finish_socket_connection (chr, sioc); } -qemu_chr_finish_socket_connection (chr, fd);return true; + + fail: +object_unref (OBJECT (sioc)); +return false; }/*********************************************************/
@@ -4125,8 +3973,6 @@ static CharDriverState *qmp_chardev_open_socket(ChardevSocket *sock, chr =qemu_chr_alloc (); s =g_malloc0 (sizeof (TCPCharDriver)); - s->fd =-1 ; - s->listen_fd =-1 ; s->is_unix = addr->kind ==SOCKET_ADDRESS_KIND_UNIX ; s->is_listen = is_listen; s->is_telnet = is_telnet;
@@ -4168,8 +4014,8 @@ static CharDriverState *qmp_chardev_open_socket(ChardevSocket *sock,if (is_listen && is_waitconnect) {fprintf (stderr,"QEMU waiting for connection on: %s\n" , chr->filename); -tcp_chr_accept (s->listen_chan,G_IO_IN , chr); -qemu_set_nonblock (s->listen_fd); +tcp_chr_accept (QIO_CHANNEL (s->listen_ioc),G_IO_IN , chr); +qio_channel_set_blocking (QIO_CHANNEL (s->listen_ioc), false); }return chr;
@@ -4178,13 +4024,15 @@ static CharDriverState *qmp_chardev_open_socket(ChardevSocket *sock,static CharDriverState *qmp_chardev_open_udp (ChardevUdp *udp,Error **errp) { -int fd; +QIOChannelSocket *sioc =qio_channel_socket_new (); - fd =socket_dgram (udp->remote, udp->local, errp); -if (fd <0 ) { +if (qio_channel_socket_dgram_sync (sioc, + udp->remote, udp->local, + errp) <0 ) { +object_unref (OBJECT (sioc));return NULL ; } -return qemu_chr_open_udp_fd (fd); +return qemu_chr_open_udp (sioc); } ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
Signature · 1 line
2.4.3
PATCH 21/46 char: don't assume telnet initialization will not block
In reply to Daniel P. BerrangeThe current code for doing telnet initialization is writing to a socket without checking the return status. While it is highly unlikely to be a problem when writing to a bare socket, as the buffers are large enough to prevent blocking, this cannot be assumed safe with TLS sockets. So write the telnet initialization code into a memory buffer and then use an I/O watch to fully send the data.
--- qemu-char.c | 85 ++++++++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 67 insertions(+), 18 deletions(-)
qemu-char.c +67 -18
@@ -2769,19 +2769,68 @@ static void tcp_chr_update_read_handler(CharDriverState *chr) } } -#define IACSET (x,a,b,c) x[0] = a; x[1] = b; x[2] = c; -static void tcp_chr_telnet_init (QIOChannel *ioc) +typedef struct { +CharDriverState *chr; +char buf[12 ]; +size_t buflen; +}TCPCharDriverTelnetInit ; + +static gboolean tcp_chr_telnet_init_io (QIOChannel *ioc, + GIOCondition cond G_GNUC_UNUSED, +gpointer user_data) { -char buf[3 ]; -/* Send the telnet negotion to put telnet in binary, no echo, single char mode */ -IACSET (buf,0xff ,0xfb ,0x01 );/* IAC WILL ECHO */ -qio_channel_write (ioc, buf,3 ,NULL ); -IACSET (buf,0xff ,0xfb ,0x03 );/* IAC WILL Suppress go ahead */ -qio_channel_write (ioc, buf,3 ,NULL ); -IACSET (buf,0xff ,0xfb ,0x00 );/* IAC WILL Binary */ -qio_channel_write (ioc, buf,3 ,NULL ); -IACSET (buf,0xff ,0xfd ,0x00 );/* IAC DO Binary */ -qio_channel_write (ioc, buf,3 ,NULL ); +TCPCharDriverTelnetInit *init = user_data; +ssize_t ret; + + ret =qio_channel_write (ioc, init->buf, init->buflen,NULL ); +if (ret <0 ) { +if (ret ==QIO_CHANNEL_ERR_BLOCK ) { + ret =0 ; + }else { +tcp_chr_disconnect (init->chr); +return FALSE; + } + } + init->buflen -= ret; + +if (init->buflen ==0 ) { +tcp_chr_connect (init->chr); +return FALSE; + } + +return TRUE; +} + +static void tcp_chr_telnet_init (CharDriverState *chr) +{ +TCPCharDriver *s = chr->opaque; +TCPCharDriverTelnetInit *init = +g_new0 (TCPCharDriverTelnetInit,1 ); +size_t n =0 ; + + init->chr = chr; + init->buflen =12 ; + +#define IACSET (x, a, b, c) \ + do { \ + x[n++] = a; \ + x[n++] = b; \ + x[n++] = c; \ + } while (0) + +/* Prep the telnet negotion to put telnet in binary, +* no echo, single char mode */ +IACSET (init->buf,0xff ,0xfb ,0x01 );/* IAC WILL ECHO */ +IACSET (init->buf,0xff ,0xfb ,0x03 );/* IAC WILL Suppress go ahead */ +IACSET (init->buf,0xff ,0xfb ,0x00 );/* IAC WILL Binary */ +IACSET (init->buf,0xff ,0xfd ,0x00 );/* IAC DO Binary */ + +#undef IACSET + +qio_channel_add_watch ( + s->ioc,G_IO_OUT , + tcp_chr_telnet_init_io, + init,NULL ); }static int tcp_chr_new_client (CharDriverState *chr,QIOChannelSocket *sioc)
@@ -2802,7 +2851,12 @@ static int tcp_chr_new_client(CharDriverState *chr, QIOChannelSocket *sioc)g_source_remove (s->listen_tag); s->listen_tag =0 ; } -tcp_chr_connect (chr); + +if (s->do_telnetopt) { +tcp_chr_telnet_init (chr); + }else { +tcp_chr_connect (chr); + }return 0 ; }
@@ -2827,7 +2881,6 @@ static gboolean tcp_chr_accept(QIOChannel *channel, void *opaque) {CharDriverState *chr = opaque; -TCPCharDriver *s = chr->opaque;QIOChannelSocket *sioc; sioc = qio_channel_socket_accept(QIO_CHANNEL_SOCKET(channel),
@@ -2836,10 +2889,6 @@ static gboolean tcp_chr_accept(QIOChannel *channel,return TRUE; } -if (s->do_telnetopt) { -tcp_chr_telnet_init (QIO_CHANNEL (sioc)); - } -tcp_chr_new_client (chr, sioc);object_unref (OBJECT (sioc));
Signature · 1 line
2.4.3
PATCH 22/46 char: introduce support for TLS encrypted TCP chardev backend
In reply to Daniel P. BerrangeThis integrates support for QIOChannelTLS object in the TCP chardev backend. If the 'tls-creds=NAME' option is passed with the '-chardev tcp' argument, then it will setup the chardev such that the client is required to establish a TLS handshake when connecting. There is no support for checking the client certificate against ACLs in this initial patch. This is pending work to QOM-ify the ACL object code.
A complete invocation to run QEMU as the server for a TLS encrypted serial dev might be
$ qemu-system-x86_64 \
-nodefconfig -nodefaults -device sga -display none \
-chardev socket,id=s0,host=127.0.0.1,port=9000,tls-creds=tls0,server \
-device isa-serial,chardev=s0 \
-object tls-creds,id=tls0,credtype=x509,\
endpoint=server,dir=/home/berrange/security/qemutls,verify-peer=offTo test with the gnutls-cli tool as the client:
$ gnutls-cli --priority=NORMAL -p 9000 \
--x509cafile=/home/berrange/security/qemutls/ca-cert.pem \
127.0.0.1If QEMU was told to use 'anon' credential type, then use the priority string 'NORMAL:+ANON-DH' with gnutls-cli
Alternatively, if setting up a chardev to operate as a client, then the TLS credentials registered must be for the client endpoint. First a TLS server must be setup, which can be done with the gnutls-serv tool
$ gnutls-serv --priority=NORMAL -p 9000 \
--x509cafile=/home/berrange/security/qemutls/ca-cert.pem \
--x509certfile=/home/berrange/security/qemutls/server-cert.pem \
--x509keyfile=/home/berrange/security/qemutls/server-key.pemThen QEMU can connect with
$ qemu-system-x86_64 \
-nodefconfig -nodefaults -device sga -display none \
-chardev socket,id=s0,host=127.0.0.1,port=9000,tls-creds=tls0 \
-device isa-serial,chardev=s0 \
-object tls-creds,id=tls0,credtype=x509,\
endpoint=client,dir=/home/berrange/security/qemutls--- qapi-schema.json | 2 + qemu-char.c | 142 ++++++++++++++++++++++++++++++++++++++++++++++++++----- qemu-options.hx | 9 +++- 3 files changed, 138 insertions(+), 15 deletions(-)
qapi-schema.json +2 -0
@@ -2910,6 +2910,7 @@ # # @addr: socket address to listen on (server=true) # or connect to (server=false) +# @tls-creds: #optional the ID of the TLS credentials object (since 2.4) # @server: #optional create server socket (default: true) # @wait: #optional wait for incoming connection on server # sockets (default: false).
@@ -2924,6 +2925,7 @@ # Since: 1.4 ## { 'struct': 'ChardevSocket', 'data': { 'addr' : 'SocketAddress', + '*tls-creds' : 'str', '*server' : 'bool', '*wait' : 'bool', '*nodelay' : 'bool',
qemu-char.c +129 -13
255 lines not on this page · raw message
qemu-options.hx +7 -2
@@ -2030,7 +2030,7 @@ ETEXI DEF("chardev", HAS_ARG, QEMU_OPTION_chardev, "-chardev null,id=id[,mux=on|off]\n" "-chardev socket,id=id[,host=host],port=port[,to=to][,ipv4][,ipv6][,nodelay][,reconnect=seconds]\n" - " [,server][,nowait][,telnet][,reconnect=seconds][,mux=on|off] (tcp)\n" + " [,server][,nowait][,telnet][,reconnect=seconds][,mux=on|off][,tls-creds=ID] (tcp)\n" "-chardev socket,id=id,path=path[,server][,nowait][,telnet][,reconnect=seconds][,mux=on|off] (unix)\n" "-chardev udp,id=id[,host=host],port=port[,localaddr=localaddr]\n" " [,localport=localport][,ipv4][,ipv6][,mux=on|off]\n"
@@ -2103,7 +2103,7 @@ Options to each backend are described below. A void device. This device will not emit any data, and will drop any data it receives. The null backend does not take any options. -@item -chardev socket ,id=@var{id} [@var{TCP options} or @var{unix options}] [,server] [,nowait] [,telnet] [,reconnect=@var{seconds}] +@item -chardev socket ,id=@var{id} [@var{TCP options} or @var{unix options}] [,server] [,nowait] [,telnet] [,reconnect=@var{seconds}] [,tls-creds=@var{id}] Create a two-way stream socket, which can be either a TCP or a unix socket. A unix socket will be created if @option{path} is specified. Behaviour is
@@ -2121,6 +2121,11 @@ escape sequences. the remote end goes away. qemu will delay this many seconds and then attempt to reconnect. Zero disables reconnecting, and is the default. +@option{tls-creds} requests enablement of the TLS protocol for encryption, +and specifies the id of the TLS credentials to use for the handshake. The +credentials must be previously created with the @option{-object tls-creds} +argument. + TCP and unix socket options are given below: @table @option
Signature · 1 line
2.4.3
PATCH 23/46 nbd: convert to use the QAPI SocketAddress object
In reply to Daniel P. BerrangeThe nbd block driver currently uses a QemuOpts objects when setting up sockets. Switch it over to use the QAPI SocketAddress objects instead.
--- block/nbd.c | 66 +++++++++++++++++++++++++++++++------------------------------ 1 file changed, 34 insertions(+), 32 deletions(-)
block/nbd.c +34 -32
@@ -43,7 +43,6 @@typedef struct BDRVNBDState {NbdClientSession client; -QemuOpts *socket_opts; }BDRVNBDState ;static int nbd_parse_uri (const char *filename,QDict *options)
@@ -190,10 +189,10 @@ out:g_free (file); } -static void nbd_config (BDRVNBDState *s,QDict *options,char **export, -Error **errp) +static SocketAddress *nbd_config (BDRVNBDState *s,QDict *options,char **export, +Error **errp) { -Error *local_err =NULL ; +SocketAddress *saddr;if (qdict_haskey (options,"path" ) ==qdict_haskey (options,"host" )) {if (qdict_haskey (options,"path" )) {
@@ -201,28 +200,34 @@ static void nbd_config(BDRVNBDState *s, QDict *options, char **export, }else {error_setg (errp,"one of path and host must be specified." ); } -return ; +return NULL ; } - s->client.is_unix =qdict_haskey (options,"path" ); - s->socket_opts =qemu_opts_create (&socket_optslist,NULL ,0 , - &error_abort); + saddr =g_new0 (SocketAddress,1 ); -qemu_opts_absorb_qdict (s->socket_opts, options, &local_err); -if (local_err) { -error_propagate (errp, local_err); -return ; +if (qdict_haskey (options,"path" )) { + saddr->kind =SOCKET_ADDRESS_KIND_UNIX ; + saddr->q_unix =g_new0 (UnixSocketAddress,1 ); + saddr->q_unix->path =g_strdup (qdict_get_str (options,"path" )); + }else { + saddr->kind =SOCKET_ADDRESS_KIND_INET ; + saddr->inet =g_new0 (InetSocketAddress,1 ); + saddr->inet->host =g_strdup (qdict_get_str (options,"host" )); +if (!qdict_get_try_str (options,"port" )) { + saddr->inet->port =g_strdup_printf ("%d" ,NBD_DEFAULT_PORT ); + }else { + saddr->inet->port =g_strdup (qdict_get_str (options,"port" )); + } } -if (!qemu_opt_get (s->socket_opts,"port" )) { -qemu_opt_set_number (s->socket_opts,"port" ,NBD_DEFAULT_PORT , - &error_abort); - } + s->client.is_unix =qdict_haskey (options,"path" ); *export =g_strdup (qdict_get_try_str (options,"export" ));if (*export) {qdict_del (options,"export" ); } + +return saddr; }NbdClientSession *nbd_get_client_session (BlockDriverState *bs)
@@ -231,26 +236,24 @@ NbdClientSession *nbd_get_client_session(BlockDriverState *bs)return &s->client; } -static int nbd_establish_connection (BlockDriverState *bs,Error **errp) +static int nbd_establish_connection (BlockDriverState *bs, +SocketAddress *saddr, +Error **errp) {BDRVNBDState *s = bs->opaque;int sock; -if (s->client.is_unix) { - sock =unix_connect_opts (s->socket_opts, errp,NULL ,NULL ); - }else { - sock =inet_connect_opts (s->socket_opts, errp,NULL ,NULL ); -if (sock >=0 ) { -socket_set_nodelay (sock); - } - } + sock =socket_connect (saddr, errp,NULL ,NULL ); -/* Failed to establish connection */ if (sock <0 ) {logout ("Failed to establish connection to NBD server\n" );return -EIO ; } +if (!s->client.is_unix) { +socket_set_nodelay (sock); + } +return sock; }
@@ -261,10 +264,11 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,char *export =NULL ;int result, sock;Error *local_err =NULL ; +SocketAddress *saddr;/* Pop the config into our state object. Exit if invalid. */ -nbd_config (s, options, &export, &local_err); -if (local_err) { + saddr =nbd_config (s, options, &export, &local_err); +if (!saddr) {error_propagate (errp, local_err);return -EINVAL ; }
@@ -272,7 +276,8 @@ static int nbd_open(BlockDriverState *bs, QDict *options, int flags,/* establish TCP connection, return error if it fails * TODO: Configurable retry-until-timeout behaviour. */ - sock =nbd_establish_connection (bs, errp); + sock =nbd_establish_connection (bs, saddr, errp); +qapi_free_SocketAddress (saddr);if (sock <0 ) {g_free (export);return sock;
@@ -315,9 +320,6 @@ static int nbd_co_discard(BlockDriverState *bs, int64_t sector_num,static void nbd_close (BlockDriverState *bs) { -BDRVNBDState *s = bs->opaque; - -qemu_opts_del (s->socket_opts);nbd_client_close (bs); }
Signature · 1 line
2.4.3
PATCH 24/46 qemu-nbd: convert to use the QAPI SocketAddress object
In reply to Daniel P. BerrangeThe qemu-nbd program currently uses a QemuOpts objects when setting up sockets. Switch it over to use the QAPI SocketAddress objects instead.
--- qemu-nbd.c | 102 +++++++++++++++++++++++-------------------------------------- 1 file changed, 38 insertions(+), 64 deletions(-)
qemu-nbd.c +38 -64
@@ -49,7 +49,7 @@static NBDExport *exp;static int verbose;static char *srcpath; -static char *sockpath; +static SocketAddress *saddr;static int persistent =0 ;static enum {RUNNING ,TERMINATE ,TERMINATING ,TERMINATED } state;static int shared =1 ;
@@ -213,52 +213,6 @@ static void termsig_handler(int signum)qemu_notify_event (); } -static void combine_addr (char *buf,size_t len,const char * address, -uint16_t port) -{ -/* If the address-part contains a colon, it's an IPv6 IP so needs [] */ -if (strstr (address,":" )) { -snprintf (buf, len,"[%s]:%u" , address, port); - }else { -snprintf (buf, len,"%s:%u" , address, port); - } -} - -static int tcp_socket_incoming (const char *address,uint16_t port) -{ -char address_and_port[128 ]; -Error *local_err =NULL ; - -combine_addr (address_and_port,128 , address, port); -int fd =inet_listen (address_and_port,NULL ,0 ,SOCK_STREAM ,0 , &local_err); - -if (local_err !=NULL ) { -error_report_err (local_err); - } -return fd; -} - -static int unix_socket_incoming (const char *path) -{ -Error *local_err =NULL ; -int fd =unix_listen (path,NULL ,0 , &local_err); - -if (local_err !=NULL ) { -error_report_err (local_err); - } -return fd; -} - -static int unix_socket_outgoing (const char *path) -{ -Error *local_err =NULL ; -int fd =unix_connect (path, &local_err); - -if (local_err !=NULL ) { -error_report_err (local_err); - } -return fd; -}static void *show_parts (void *arg) {
@@ -287,8 +241,10 @@ static void *nbd_client_thread(void *arg)pthread_t show_parts_thread;Error *local_error =NULL ; - sock =unix_socket_outgoing (sockpath); + + sock =socket_connect (saddr, &local_error,NULL ,NULL );if (sock <0 ) { +error_report_err (local_error); goto out; }
@@ -399,6 +355,33 @@ static void nbd_update_server_fd_handler(int fd) } } + +static SocketAddress *nbd_build_socket_address (const char *sockpath, +const char *bindto, +const char *port) +{ +SocketAddress *saddr; + + saddr =g_new0 (SocketAddress,1 ); +if (sockpath) { + saddr->kind =SOCKET_ADDRESS_KIND_UNIX ; + saddr->q_unix =g_new0 (UnixSocketAddress,1 ); + saddr->q_unix->path =g_strdup (sockpath); + }else { + saddr->kind =SOCKET_ADDRESS_KIND_INET ; + saddr->inet =g_new0 (InetSocketAddress,1 ); + saddr->inet->host =g_strdup (bindto); +if (port) { + saddr->inet->port =g_strdup (port); + }else { + saddr->inet->port =g_strdup_printf ("%d" ,NBD_DEFAULT_PORT ); + } + } + +return saddr; +} + +int main (int argc,char **argv) {BlockBackend *blk;
@@ -407,8 +390,9 @@ int main(int argc, char **argv)uint32_t nbdflags =0 ;bool disconnect = false;const char *bindto ="0.0.0.0" ; +const char *port =NULL ; +char *sockpath =NULL ;char *device =NULL ; -int port =NBD_DEFAULT_PORT ;off_t fd_size;QemuOpts *sn_opts =NULL ;const char *sn_id_or_name =NULL ;
@@ -441,7 +425,6 @@ int main(int argc, char **argv) };int ch;int opt_ind =0 ; -int li;char *end;int flags =BDRV_O_RDWR ;int partition =-1 ;
@@ -529,14 +512,7 @@ int main(int argc, char **argv) bindto = optarg;break ;case 'p' : - li =strtol (optarg, &end,0 ); -if (*end) { -errx (EXIT_FAILURE ,"Invalid port `%s'" , optarg); - } -if (li <1 || li >65535 ) { -errx (EXIT_FAILURE ,"Port out of range `%s'" , optarg); - } - port = (uint16_t )li; + port = optarg;break ;case 'o' : dev_offset =strtoll (optarg, &end,0 );
@@ -695,6 +671,8 @@ int main(int argc, char **argv)snprintf (sockpath,128 ,SOCKET_PATH ,basename (device)); } + saddr =nbd_build_socket_address (sockpath, bindto, port); +if (qemu_init_main_loop (&local_err)) {error_report_err (local_err);exit (EXIT_FAILURE );
@@ -752,13 +730,9 @@ int main(int argc, char **argv)errx (EXIT_FAILURE ,"%s" ,error_get_pretty (local_err)); } -if (sockpath) { - fd =unix_socket_incoming (sockpath); - }else { - fd =tcp_socket_incoming (bindto, port); - } - + fd =socket_listen (saddr, &local_err);if (fd <0 ) { +error_report_err (local_err);return 1 ; }
Signature · 1 line
2.4.3
PATCH 25/46 sockets: remove use of QemuOpts from header file
In reply to Daniel P. BerrangeThere are no callers of the sockets methods which accept QemuOpts any more. Make all the QemuOpts related functions static to avoid new callers being added, in preparation for removal of all QemuOpts usage, in favour of QAPI SocketAddress.
--- include/qemu/sockets.h | 9 --------- util/qemu-sockets.c | 22 +++++++++++----------- 2 files changed, 11 insertions(+), 20 deletions(-)
include/qemu/sockets.h +0 -9
@@ -30,8 +30,6 @@ int inet_aton(const char *cp, struct in_addr *ia);#include "qapi/error.h" #include "qapi-types.h" -extern QemuOptsList socket_optslist; -/* misc helpers */ int qemu_socket (int domain,int type,int protocol);int qemu_accept (int s,struct sockaddr *addr,socklen_t *addrlen);
@@ -56,23 +54,16 @@ int recv_all(int fd, void *buf, int len1, bool single_read);typedef void NonBlockingConnectHandler (int fd,Error *errp,void *opaque);InetSocketAddress *inet_parse (const char *str,Error **errp); -int inet_listen_opts (QemuOpts *opts,int port_offset,Error **errp);int inet_listen (const char *str,char *ostr,int olen,int socktype,int port_offset,Error **errp); -int inet_connect_opts (QemuOpts *opts,Error **errp, -NonBlockingConnectHandler *callback,void *opaque);int inet_connect (const char *str,Error **errp);int inet_nonblocking_connect (const char *str,NonBlockingConnectHandler *callback,void *opaque,Error **errp); -int inet_dgram_opts (QemuOpts *opts,Error **errp);NetworkAddressFamily inet_netfamily (int family); -int unix_listen_opts (QemuOpts *opts,Error **errp);int unix_listen (const char *path,char *ostr,int olen,Error **errp); -int unix_connect_opts (QemuOpts *opts,Error **errp, -NonBlockingConnectHandler *callback,void *opaque);int unix_connect (const char *path,Error **errp); int unix_nonblocking_connect(const char *str, NonBlockingConnectHandler *callback,
util/qemu-sockets.c +11 -11
@@ -37,7 +37,7 @@#endif /* used temporarily until all users are converted to QemuOpts */ -QemuOptsList socket_optslist = { +static QemuOptsList socket_optslist = { .name ="socket" , .head =QTAILQ_HEAD_INITIALIZER (socket_optslist.head), .desc = {
@@ -114,7 +114,7 @@ NetworkAddressFamily inet_netfamily(int family)return NETWORK_ADDRESS_FAMILY_UNKNOWN ; } -int inet_listen_opts (QemuOpts *opts,int port_offset,Error **errp) +static int inet_listen_opts (QemuOpts *opts,int port_offset,Error **errp) {struct addrinfo ai,*res,*e;const char *addr;
@@ -392,8 +392,8 @@ static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)* function succeeds, callback will be called when the connection * completes, with the file descriptor on success, or -1 on error. */ -int inet_connect_opts (QemuOpts *opts,Error **errp, -NonBlockingConnectHandler *callback,void *opaque) +static int inet_connect_opts (QemuOpts *opts,Error **errp, +NonBlockingConnectHandler *callback,void *opaque) {Error *local_err =NULL ;struct addrinfo *res, *e;
@@ -440,7 +440,7 @@ int inet_connect_opts(QemuOpts *opts, Error **errp,return sock; } -int inet_dgram_opts (QemuOpts *opts,Error **errp) +static int inet_dgram_opts (QemuOpts *opts,Error **errp) {struct addrinfo ai, *peer =NULL , *local =NULL ;const char *addr;
@@ -705,7 +705,7 @@ int inet_nonblocking_connect(const char *str,#ifndef _WIN32 -int unix_listen_opts (QemuOpts *opts,Error **errp) +static int unix_listen_opts (QemuOpts *opts,Error **errp) {struct sockaddr_un un;const char *path =qemu_opt_get (opts,"path" );
@@ -770,8 +770,8 @@ err:return -1 ; } -int unix_connect_opts (QemuOpts *opts,Error **errp, -NonBlockingConnectHandler *callback,void *opaque) +static int unix_connect_opts (QemuOpts *opts,Error **errp, +NonBlockingConnectHandler *callback,void *opaque) {struct sockaddr_un un;const char *path =qemu_opt_get (opts,"path" );
@@ -830,15 +830,15 @@ int unix_connect_opts(QemuOpts *opts, Error **errp,#else -int unix_listen_opts (QemuOpts *opts,Error **errp) +static int unix_listen_opts (QemuOpts *opts,Error **errp) {error_setg (errp,"unix sockets are not available on windows" ); errno =ENOTSUP ;return -1 ; } -int unix_connect_opts (QemuOpts *opts,Error **errp, -NonBlockingConnectHandler *callback,void *opaque) +static int unix_connect_opts (QemuOpts *opts,Error **errp, +NonBlockingConnectHandler *callback,void *opaque) {error_setg (errp,"unix sockets are not available on windows" ); errno =ENOTSUP ;
Signature · 1 line
2.4.3
PATCH 26/46 sockets: remove use of QemuOpts from socket_listen
In reply to Daniel P. BerrangeThe socket_listen method accepts a QAPI SocketAddress object which it then turns into QemuOpts before calling the inet_listen_opts/unix_listen_opts helper methods. By converting the latter to use QAPI SocketAddress directly, the QemuOpts conversion step can be eliminated
--- util/qemu-sockets.c | 106 ++++++++++++++++++++++++++-------------------------- 1 file changed, 53 insertions(+), 53 deletions(-)
util/qemu-sockets.c +53 -53
@@ -114,36 +114,38 @@ NetworkAddressFamily inet_netfamily(int family)return NETWORK_ADDRESS_FAMILY_UNKNOWN ; } -static int inet_listen_opts (QemuOpts *opts,int port_offset,Error **errp) +static int inet_listen_saddr (InetSocketAddress *saddr, +int port_offset, +bool update_addr, +Error **errp) {struct addrinfo ai,*res,*e; -const char *addr;char port[33 ];char uaddr[INET6_ADDRSTRLEN +1 ];char uport[33 ]; -int slisten, rc, to, port_min, port_max, p; +int slisten, rc, port_min, port_max, p;memset (&ai,0 ,sizeof (ai)); ai.ai_flags =AI_PASSIVE ; ai.ai_family =PF_UNSPEC ; ai.ai_socktype =SOCK_STREAM ; -if ((qemu_opt_get (opts,"host" ) ==NULL )) { +if (saddr->host ==NULL ) {error_setg (errp,"host not specified" );return -1 ; } -if (qemu_opt_get (opts,"port" ) !=NULL ) { -pstrcpy (port,sizeof (port),qemu_opt_get (opts,"port" )); +if (saddr->port !=NULL ) { +pstrcpy (port,sizeof (port), saddr->port); }else { port[0 ] ='\0' ; } - addr =qemu_opt_get (opts,"host" ); - to =qemu_opt_get_number (opts,"to" ,0 ); -if (qemu_opt_get_bool (opts,"ipv4" ,0 )) +if (saddr->has_ipv4 && saddr->ipv4) { ai.ai_family =PF_INET ; -if (qemu_opt_get_bool (opts,"ipv6" ,0 )) + } +if (saddr->has_ipv6 && saddr->ipv6) { ai.ai_family =PF_INET6 ; + }/* lookup */ if (port_offset) {
@@ -163,11 +165,11 @@ static int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp) }snprintf (port,sizeof (port),"%d" , (int )baseport + port_offset); } - rc =getaddrinfo (strlen (addr) ? addr :NULL , + rc =getaddrinfo (saddr->host ? saddr->host :NULL ,strlen (port) ? port :NULL , &ai, &res);if (rc !=0 ) { -error_setg (errp,"address resolution failed for %s:%s: %s" , addr, port, -gai_strerror (rc)); +error_setg (errp,"address resolution failed for %s:%s: %s" , + saddr->host, port,gai_strerror (rc));return -1 ; }
@@ -195,7 +197,7 @@ static int inet_listen_opts(QemuOpts *opts, int port_offset, Error **errp)#endif port_min =inet_getport (e); - port_max = to ? to + port_offset : port_min; + port_max = saddr->has_to ? saddr->to + port_offset : port_min;for (p = port_min; p <= port_max; p++) {inet_setport (e, p);if (bind (slisten, e->ai_addr, e->ai_addrlen) ==0 ) {
@@ -219,13 +221,15 @@ listen:freeaddrinfo (res);return -1 ; } -qemu_opt_set (opts,"host" , uaddr, &error_abort); -qemu_opt_set_number (opts,"port" ,inet_getport (e) - port_offset, - &error_abort); -qemu_opt_set_bool (opts,"ipv6" , e->ai_family ==PF_INET6 , - &error_abort); -qemu_opt_set_bool (opts,"ipv4" , e->ai_family !=PF_INET6 , - &error_abort); +if (update_addr) { +g_free (saddr->host); + saddr->host =g_strdup (uaddr); +g_free (saddr->port); + saddr->port =g_strdup_printf ("%d" , +inet_getport (e) - port_offset); + saddr->has_ipv6 = saddr->ipv6 = e->ai_family ==PF_INET6 ; + saddr->has_ipv4 = saddr->ipv4 = e->ai_family !=PF_INET6 ; + }freeaddrinfo (res);return slisten; }
@@ -614,32 +618,28 @@ static void inet_addr_to_opts(QemuOpts *opts, const InetSocketAddress *addr)int inet_listen (const char *str,char *ostr,int olen,int socktype,int port_offset,Error **errp) { -QemuOpts *opts;char *optstr;int sock =-1 ;InetSocketAddress *addr; addr =inet_parse (str, errp);if (addr !=NULL ) { - opts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort); -inet_addr_to_opts (opts, addr); -qapi_free_InetSocketAddress (addr); - sock =inet_listen_opts (opts, port_offset, errp); + sock =inet_listen_saddr (addr, port_offset, true, errp);if (sock !=-1 && ostr) { optstr =strchr (str,',' ); -if (qemu_opt_get_bool (opts,"ipv6" ,0 )) { +if (addr->ipv6) {snprintf (ostr, olen,"[%s]:%s%s" , -qemu_opt_get (opts,"host" ), -qemu_opt_get (opts,"port" ), + addr->host, + addr->port, optstr ? optstr :"" ); }else {snprintf (ostr, olen,"%s:%s%s" , -qemu_opt_get (opts,"host" ), -qemu_opt_get (opts,"port" ), + addr->host, + addr->port, optstr ? optstr :"" ); } } -qemu_opts_del (opts); +qapi_free_InetSocketAddress (addr); }return sock; }
@@ -705,10 +705,11 @@ int inet_nonblocking_connect(const char *str,#ifndef _WIN32 -static int unix_listen_opts (QemuOpts *opts,Error **errp) +static int unix_listen_saddr (UnixSocketAddress *saddr, +bool update_addr, +Error **errp) {struct sockaddr_un un; -const char *path =qemu_opt_get (opts,"path" );int sock, fd; sock =qemu_socket (PF_UNIX ,SOCK_STREAM ,0 );
@@ -719,8 +720,8 @@ static int unix_listen_opts(QemuOpts *opts, Error **errp)memset (&un,0 ,sizeof (un)); un.sun_family =AF_UNIX ; -if (path &&strlen (path)) { -snprintf (un.sun_path,sizeof (un.sun_path),"%s" , path); +if (saddr->path &&strlen (saddr->path)) { +snprintf (un.sun_path,sizeof (un.sun_path),"%s" , saddr->path); }else {const char *tmpdir =getenv ("TMPDIR" ); tmpdir = tmpdir ? tmpdir :"/tmp" ;
@@ -745,7 +746,10 @@ static int unix_listen_opts(QemuOpts *opts, Error **errp) goto err; }close (fd); -qemu_opt_set (opts,"path" , un.sun_path, &error_abort); +if (update_addr) { +g_free (saddr->path); + saddr->path =g_strdup (un.sun_path); + } } if ((access(un.sun_path, F_OK) == 0) &&
@@ -830,7 +834,9 @@ static int unix_connect_opts(QemuOpts *opts, Error **errp,#else -static int unix_listen_opts (QemuOpts *opts,Error **errp) +static int unix_listen_saddr (UnixSocketAddress *saddr, +bool update_addr, +Error **errp) {error_setg (errp,"unix sockets are not available on windows" ); errno =ENOTSUP ;
@@ -849,11 +855,11 @@ static int unix_connect_opts(QemuOpts *opts, Error **errp,/* compatibility wrapper */ int unix_listen (const char *str,char *ostr,int olen,Error **errp) { -QemuOpts *opts;char *path, *optstr;int sock, len; +UnixSocketAddress *saddr; - opts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort); + saddr =g_new0 (UnixSocketAddress,1 ); optstr =strchr (str,',' );if (optstr) {
@@ -861,18 +867,17 @@ int unix_listen(const char *str, char *ostr, int olen, Error **errp)if (len) { path =g_malloc (len+1 );snprintf (path, len+1 ,"%.*s" , len, str); -qemu_opt_set (opts,"path" , path, &error_abort); -g_free (path); + saddr->path = path; } }else { -qemu_opt_set (opts,"path" , str, &error_abort); + saddr->path =g_strdup (str); } - sock =unix_listen_opts (opts, errp); + sock =unix_listen_saddr (saddr, true, errp);if (sock !=-1 && ostr) -snprintf (ostr, olen,"%s%s" ,qemu_opt_get (opts,"path" ), optstr ? optstr :"" ); -qemu_opts_del (opts); +snprintf (ostr, olen,"%s%s" , saddr->path, optstr ? optstr :"" ); +qapi_free_UnixSocketAddress (saddr);return sock; }
@@ -977,19 +982,15 @@ int socket_connect(SocketAddress *addr, Error **errp,int socket_listen (SocketAddress *addr,Error **errp) { -QemuOpts *opts;int fd; - opts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort);switch (addr->kind) {case SOCKET_ADDRESS_KIND_INET : -inet_addr_to_opts (opts, addr->inet); - fd =inet_listen_opts (opts,0 , errp); + fd =inet_listen_saddr (addr->inet,0 , false, errp);break ;case SOCKET_ADDRESS_KIND_UNIX : -qemu_opt_set (opts,"path" , addr->q_unix->path, &error_abort); - fd =unix_listen_opts (opts, errp); + fd =unix_listen_saddr (addr->q_unix, false, errp);break ;case SOCKET_ADDRESS_KIND_FD :
@@ -999,7 +1000,6 @@ int socket_listen(SocketAddress *addr, Error **errp)default :abort (); } -qemu_opts_del (opts);return fd; }
Signature · 1 line
2.4.3
PATCH 27/46 sockets: remove use of QemuOpts from socket_connect
In reply to Daniel P. BerrangeThe socket_connect method accepts a QAPI SocketAddress object which it then turns into QemuOpts before calling the inet_connect_opts/unix_connect_opts helper methods. By converting the latter to use QAPI SocketAddress directly, the QemuOpts conversion step can be eliminated
--- util/qemu-sockets.c | 82 +++++++++++++++++++++-------------------------------- 1 file changed, 32 insertions(+), 50 deletions(-)
util/qemu-sockets.c +32 -50
@@ -344,12 +344,11 @@ static int inet_connect_addr(struct addrinfo *addr, bool *in_progress,return sock; } -static struct addrinfo *inet_parse_connect_opts (QemuOpts *opts,Error **errp) +static struct addrinfo *inet_parse_connect_saddr (InetSocketAddress *saddr, +Error **errp) {struct addrinfo ai, *res;int rc; -const char *addr; -const char *port;memset (&ai,0 ,sizeof (ai));
@@ -357,25 +356,23 @@ static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp) ai.ai_family =PF_UNSPEC ; ai.ai_socktype =SOCK_STREAM ; - addr =qemu_opt_get (opts,"host" ); - port =qemu_opt_get (opts,"port" ); -if (addr ==NULL || port ==NULL ) { +if (saddr->host ==NULL || saddr->port ==NULL ) {error_setg (errp,"host and/or port not specified" );return NULL ; } -if (qemu_opt_get_bool (opts,"ipv4" ,0 )) { +if (saddr->has_ipv4 && saddr->ipv4) { ai.ai_family =PF_INET ; } -if (qemu_opt_get_bool (opts,"ipv6" ,0 )) { +if (saddr->has_ipv6 && saddr->ipv6) { ai.ai_family =PF_INET6 ; }/* lookup */ - rc =getaddrinfo (addr, port, &ai, &res); + rc =getaddrinfo (saddr->host, saddr->port, &ai, &res);if (rc !=0 ) { -error_setg (errp,"address resolution failed for %s:%s: %s" , addr, port, -gai_strerror (rc)); +error_setg (errp,"address resolution failed for %s:%s: %s" , + saddr->host, saddr->port,gai_strerror (rc));return NULL ; }return res;
@@ -384,8 +381,7 @@ static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)/** * Create a socket and connect it to an address. * -* @opts: QEMU options, recognized parameters strings "host" and "port", -* bools "ipv4" and "ipv6". +* @saddr: Inet socket address specification * @errp: set on error * @callback: callback function for non-blocking connect * @opaque: opaque for callback function
@@ -396,8 +392,8 @@ static struct addrinfo *inet_parse_connect_opts(QemuOpts *opts, Error **errp)* function succeeds, callback will be called when the connection * completes, with the file descriptor on success, or -1 on error. */ -static int inet_connect_opts (QemuOpts *opts,Error **errp, -NonBlockingConnectHandler *callback,void *opaque) +static int inet_connect_saddr (InetSocketAddress *saddr,Error **errp, +NonBlockingConnectHandler *callback,void *opaque) {Error *local_err =NULL ;struct addrinfo *res, *e;
@@ -405,7 +401,7 @@ static int inet_connect_opts(QemuOpts *opts, Error **errp,bool in_progress;ConnectState *connect_state =NULL ; - res =inet_parse_connect_opts (opts, errp); + res =inet_parse_connect_saddr (saddr, errp);if (!res) {return -1 ; }
@@ -654,17 +650,13 @@ int inet_listen(const char *str, char *ostr, int olen,**/ int inet_connect (const char *str,Error **errp) { -QemuOpts *opts;int sock =-1 ;InetSocketAddress *addr; addr =inet_parse (str, errp);if (addr !=NULL ) { - opts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort); -inet_addr_to_opts (opts, addr); + sock =inet_connect_saddr (addr, errp,NULL ,NULL );qapi_free_InetSocketAddress (addr); - sock =inet_connect_opts (opts, errp,NULL ,NULL ); -qemu_opts_del (opts); }return sock; }
@@ -686,7 +678,6 @@ int inet_nonblocking_connect(const char *str, NonBlockingConnectHandler *callback, void *opaque, Error **errp) { -QemuOpts *opts;int sock =-1 ;InetSocketAddress *addr;
@@ -694,11 +685,8 @@ int inet_nonblocking_connect(const char *str, addr =inet_parse (str, errp);if (addr !=NULL ) { - opts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort); -inet_addr_to_opts (opts, addr); + sock =inet_connect_saddr (addr, errp, callback, opaque);qapi_free_InetSocketAddress (addr); - sock =inet_connect_opts (opts, errp, callback, opaque); -qemu_opts_del (opts); }return sock; }
@@ -774,15 +762,14 @@ err:return -1 ; } -static int unix_connect_opts (QemuOpts *opts,Error **errp, -NonBlockingConnectHandler *callback,void *opaque) +static int unix_connect_saddr (UnixSocketAddress *saddr,Error **errp, +NonBlockingConnectHandler *callback,void *opaque) {struct sockaddr_un un; -const char *path =qemu_opt_get (opts,"path" );ConnectState *connect_state =NULL ;int sock, rc; -if (path ==NULL ) { +if (saddr->path ==NULL ) {error_setg (errp,"unix connect: no path specified" );return -1 ; }
@@ -801,7 +788,7 @@ static int unix_connect_opts(QemuOpts *opts, Error **errp,memset (&un,0 ,sizeof (un)); un.sun_family =AF_UNIX ; -snprintf (un.sun_path,sizeof (un.sun_path),"%s" , path); +snprintf (un.sun_path,sizeof (un.sun_path),"%s" , saddr->path);/* connect to peer */ do {
@@ -843,8 +830,8 @@ static int unix_listen_saddr(UnixSocketAddress *saddr,return -1 ; } -static int unix_connect_opts (QemuOpts *opts,Error **errp, -NonBlockingConnectHandler *callback,void *opaque) +static int unix_connect_saddr (UnixSocketAddress *saddr,Error **errp, +NonBlockingConnectHandler *callback,void *opaque) {error_setg (errp,"unix sockets are not available on windows" ); errno =ENOTSUP ;
@@ -883,13 +870,13 @@ int unix_listen(const char *str, char *ostr, int olen, Error **errp)int unix_connect (const char *path,Error **errp) { -QemuOpts *opts; +UnixSocketAddress *saddr;int sock; - opts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort); -qemu_opt_set (opts,"path" , path, &error_abort); - sock =unix_connect_opts (opts, errp,NULL ,NULL ); -qemu_opts_del (opts); + saddr =g_new0 (UnixSocketAddress,1 ); + saddr->path =g_strdup (path); + sock =unix_connect_saddr (saddr, errp,NULL ,NULL ); +qapi_free_UnixSocketAddress (saddr);return sock; }
@@ -898,15 +885,15 @@ int unix_nonblocking_connect(const char *path, NonBlockingConnectHandler *callback, void *opaque, Error **errp) { -QemuOpts *opts; +UnixSocketAddress *saddr;int sock =-1 ;g_assert (callback !=NULL ); - opts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort); -qemu_opt_set (opts,"path" , path, &error_abort); - sock =unix_connect_opts (opts, errp, callback, opaque); -qemu_opts_del (opts); + saddr =g_new0 (UnixSocketAddress,1 ); + saddr->path =g_strdup (path); + sock =unix_connect_saddr (saddr, errp, callback, opaque); +qapi_free_UnixSocketAddress (saddr);return sock; }
@@ -950,19 +937,15 @@ fail:int socket_connect (SocketAddress *addr,Error **errp,NonBlockingConnectHandler *callback,void *opaque) { -QemuOpts *opts;int fd; - opts =qemu_opts_create (&socket_optslist,NULL ,0 , &error_abort);switch (addr->kind) {case SOCKET_ADDRESS_KIND_INET : -inet_addr_to_opts (opts, addr->inet); - fd =inet_connect_opts (opts, errp, callback, opaque); + fd =inet_connect_saddr (addr->inet, errp, callback, opaque);break ;case SOCKET_ADDRESS_KIND_UNIX : -qemu_opt_set (opts,"path" , addr->q_unix->path, &error_abort); - fd =unix_connect_opts (opts, errp, callback, opaque); + fd =unix_connect_saddr (addr->q_unix, errp, callback, opaque);break ;case SOCKET_ADDRESS_KIND_FD :
@@ -976,7 +959,6 @@ int socket_connect(SocketAddress *addr, Error **errp,default :abort (); } -qemu_opts_del (opts);return fd; }
Signature · 1 line
2.4.3
PATCH 28/46 sockets: remove use of QemuOpts from socket_dgram
In reply to Daniel P. BerrangeThe socket_dgram method accepts a QAPI SocketAddress object which it then turns into QemuOpts before calling the inet_dgram_opts helper method. By converting the latter to use QAPI SocketAddress directly, the QemuOpts conversion step can be eliminated.
This removes the very last use of QemuOpts from the sockets code, so the socket_optslist[] array is also removed.
--- include/qemu/sockets.h | 1 - util/qemu-sockets.c | 89 ++++++++++++-------------------------------------- 2 files changed, 21 insertions(+), 69 deletions(-)
include/qemu/sockets.h +0 -1
@@ -26,7 +26,6 @@ int inet_aton(const char *cp, struct in_addr *ia);#endif /* !_WIN32 */ -#include "qemu/option.h" #include "qapi/error.h" #include "qapi-types.h"
util/qemu-sockets.c +21 -68
145 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 29/46 migration: remove use of qemu_bufopen from vmstate tests
In reply to Daniel P. BerrangeThe test-vmstate.c file is the only remaining user of the qemu_bufopen function. Half of the test cases already use a temporary file, so convert the remaining cases to match
--- tests/Makefile | 2 +- tests/test-vmstate.c | 44 +++++++++++++------------------------------- 2 files changed, 14 insertions(+), 32 deletions(-)
tests/Makefile +1 -1
@@ -320,7 +320,7 @@ tests/test-qdev-global-props$(EXESUF): tests/test-qdev-global-props.o \ hw/core/fw-path-provider.o \ $(test-qapi-obj-y) tests/test-vmstate$(EXESUF): tests/test-vmstate.o \ - migration/vmstate.o migration/qemu-file.o migration/qemu-file-buf.o \ + migration/vmstate.o migration/qemu-file.o \ migration/qemu-file-unix.o qjson.o \ $(test-qom-obj-y)
tests/test-vmstate.c +13 -31
115 lines not on this page · raw message
Signature · 1 line
2.4.3
Re: [Qemu-devel] [PATCH FYI 29/46] migration: remove use of qemu_bufopen from vmstate tests
Quoted 3 lines · * Daniel P. Berrange ([email protected]) wrote:
The
test-vmstate.cfile is the only remaining user of theqemu_bufopenfunction. Half of the test cases already use a temporary file, so convert the remaining cases to match
As mentioned on irc; the buffered stuff is used by the postcopy series and COLO.
Dave
Quoted 150 lines
Signed-off-by Daniel P. Berrange <[email protected]>--- tests/Makefile | 2 +- tests/test-vmstate.c | 44 +++++++++++++------------------------------- 2 files changed, 14 insertions(+), 32 deletions(-)tests/Makefile +1
-1@@ -320,7 +320,7 @@ tests/test-qdev-global-props$(EXESUF): tests/test-qdev-global-props.o \ hw/core/fw-path-provider.o \ $(test-qapi-obj-y) tests/test-vmstate$(EXESUF): tests/test-vmstate.o \ - migration/vmstate.o migration/qemu-file.o migration/qemu-file-buf.o \ + migration/vmstate.o migration/qemu-file.o \ migration/qemu-file-unix.o qjson.o \ $(test-qom-obj-y)tests/test-vmstate.c +13
-31@@ -43,11 +43,6 @@ void yield_until_fd_readable(int fd)select (fd +1 , &fds,NULL ,NULL ,NULL ); } -/* -* Some tests use 'open_test_file' to work on a real fd, some use -* an in memory file (QEMUSizedBuffer+qemu_bufopen); we could pick one -* but this way we test both. -*/ /* Duplicate temp_fd and seek to the beginning of the file */ static QEMUFile *open_test_file (bool write)@@ -60,20 +55,6 @@ static QEMUFile *open_test_file(bool write)return qemu_fdopen (fd, write ?"wb" :"rb" ); } -/* -* Check that the contents of the memory-buffered file f match -* the given size/data. -*/ -static void check_mem_file (QEMUFile *f,void *data,size_t size) -{ -uint8_t *result =g_malloc (size); -const QEMUSizedBuffer *qsb =qemu_buf_get (f); - g_assert_cmpint(qsb_get_length(qsb), ==, size); - g_assert_cmpint(qsb_get_buffer(qsb, 0, size, result), ==, size); - g_assert_cmpint(memcmp(result, data, size), ==, 0); -g_free (result); -} -#define SUCCESS (val) \ g_assert_cmpint((val), ==, 0)@@ -391,7 +372,7 @@ static const VMStateDescription vmstate_skipping = {static void test_save_noskip (void ) { -QEMUFile *fsave =qemu_bufopen ("w" ,NULL ); +QEMUFile *fsave =open_test_file (true);TestStruct obj = { .a =1 , .b =2 , .c =3 , .d =4 , .e =5 , .f =6 , .skip_c_e = false };vmstate_save_state (fsave, &vmstate_skipping, &obj,NULL );@@ -405,13 +386,14 @@ static void test_save_noskip(void)0 ,0 ,0 ,5 ,/* e */ 0 ,0 ,0 ,0 ,0 ,0 ,0 ,6 ,/* f */ }; -check_mem_file (fsave, expected,sizeof (expected)); +qemu_fclose (fsave); +compare_vmstate (expected,sizeof (expected)); }static void test_save_skip (void ) { -QEMUFile *fsave =qemu_bufopen ("w" ,NULL ); +QEMUFile *fsave =open_test_file (true);TestStruct obj = { .a =1 , .b =2 , .c =3 , .d =4 , .e =5 , .f =6 , .skip_c_e = true };vmstate_save_state (fsave, &vmstate_skipping, &obj,NULL );@@ -423,13 +405,14 @@ static void test_save_skip(void)0 ,0 ,0 ,0 ,0 ,0 ,0 ,4 ,/* d */ 0, 0, 0, 0, 0, 0, 0, 6, /* f */ }; -check_mem_file (fsave, expected,sizeof (expected));qemu_fclose (fsave); +compare_vmstate (expected,sizeof (expected)); }static void test_load_noskip (void ) { +QEMUFile *fsave =open_test_file (true);uint8_t buf[] = {0 ,0 ,0 ,10 ,/* a */ 0, 0, 0, 20, /* b */@@ -439,10 +422,10 @@ static void test_load_noskip(void)0 ,0 ,0 ,0 ,0 ,0 ,0 ,60 ,/* f */ QEMU_VM_EOF ,/* just to ensure we won't get EOF reported prematurely */ }; +qemu_put_buffer (fsave, buf,sizeof (buf)); +qemu_fclose (fsave); - QEMUSizedBuffer *qsb =qsb_create (buf,sizeof (buf)); -g_assert (qsb); -QEMUFile *loading =qemu_bufopen ("r" , qsb); +QEMUFile *loading =open_test_file (false);TestStruct obj = { .skip_c_e = false };vmstate_load_state (loading, &vmstate_skipping, &obj,2 );g_assert (!qemu_file_get_error (loading));@@ -453,11 +436,11 @@ static void test_load_noskip(void) g_assert_cmpint(obj.e, ==, 50); g_assert_cmpint(obj.f, ==, 60);qemu_fclose (loading); -qsb_free (qsb); }static void test_load_skip (void ) { +QEMUFile *fsave =open_test_file (true);uint8_t buf[] = {0 ,0 ,0 ,10 ,/* a */ 0 ,0 ,0 ,20 ,/* b */ @@ -465,10 +448,10 @@ static void test_load_skip(void)0 ,0 ,0 ,0 ,0 ,0 ,0 ,60 ,/* f */ QEMU_VM_EOF ,/* just to ensure we won't get EOF reported prematurely */ }; +qemu_put_buffer (fsave, buf,sizeof (buf)); +qemu_fclose (fsave); - QEMUSizedBuffer *qsb =qsb_create (buf,sizeof (buf)); -g_assert (qsb); -QEMUFile *loading =qemu_bufopen ("r" , qsb); +QEMUFile *loading =open_test_file (false);TestStruct obj = { .skip_c_e = true, .c =300 , .e =500 };vmstate_load_state (loading, &vmstate_skipping, &obj,2 );g_assert (!qemu_file_get_error (loading));@@ -479,7 +462,6 @@ static void test_load_skip(void) g_assert_cmpint(obj.e, ==, 500); g_assert_cmpint(obj.f, ==, 60);qemu_fclose (loading); -qsb_free (qsb); }int main (int argc,char **argv)Signature · 1 line
2.4.3
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Re: [Qemu-devel] [PATCH FYI 29/46] migration: remove use of qemu_bufopen from vmstate tests
Quoted 7 lines · Dr. David Alan Gilbert
Quoted 3 lines · * Daniel P. Berrange ([email protected]) wrote:
The
test-vmstate.cfile is the only remaining user of theqemu_bufopenfunction. Half of the test cases already use a temporary file, so convert the remaining cases to matchAs mentioned on irc; the buffered stuff is used by the postcopy series and COLO.
Yep, there's nothing in my series (yet) that really requires that we delete this QEMUFile impl. I was just trying to see if it was possible to get to a point where the /only/ QEMUFile impl was the QIOChannel one. I almost succeeded in that, the exception being the impl needed for writing internal QCow2 snapshots. I'll look at creating a memory buffer based QIOChannel, or alternatively just drop this patch, to avoid breaking COLO/postcopy.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
PATCH 30/46 migration: remove memory buffer based QEMUFile backend
In reply to Daniel P. BerrangeThe qemu_bufopen() method is no longer used, so the memory buffer based QEMUFile backend can be deleted entirely.
--- include/migration/qemu-file.h | 15 -- migration/Makefile.objs | 2 +- migration/qemu-file-buf.c | 462 ------------------------------------------ 3 files changed, 1 insertion(+), 478 deletions(-) delete mode 100644 migration/qemu-file-buf.c
include/migration/qemu-file.h +0 -15
@@ -121,7 +121,6 @@ QEMUFile *qemu_fopen(const char *filename, const char *mode);QEMUFile *qemu_fdopen (int fd,const char *mode);QEMUFile *qemu_fopen_socket (int fd,const char *mode);QEMUFile *qemu_popen_cmd (const char *command,const char *mode); -QEMUFile *qemu_bufopen (const char *mode,QEMUSizedBuffer *input);int qemu_get_fd (QEMUFile *f);int qemu_fclose (QEMUFile *f);int64_t qemu_ftell (QEMUFile *f);
@@ -136,20 +135,6 @@ void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size);bool qemu_file_mode_is_not_valid (const char *mode);bool qemu_file_is_writable (QEMUFile *f); -QEMUSizedBuffer *qsb_create (const uint8_t *buffer,size_t len); -void qsb_free (QEMUSizedBuffer *); -size_t qsb_set_length (QEMUSizedBuffer *qsb,size_t length); -size_t qsb_get_length (const QEMUSizedBuffer *qsb); -ssize_t qsb_get_buffer (const QEMUSizedBuffer *,off_t start,size_t count, -uint8_t *buf); -ssize_t qsb_write_at (QEMUSizedBuffer *qsb,const uint8_t *buf, -off_t pos,size_t count); - - -/* -* For use on files opened with qemu_bufopen -*/ -const QEMUSizedBuffer *qemu_buf_get (QEMUFile *f);static inline void qemu_put_ubyte (QEMUFile *f,unsigned int v) {
migration/Makefile.objs +1 -1
@@ -1,6 +1,6 @@ common-obj-y += migration.o tcp.o common-obj-y += vmstate.o -common-obj-y += qemu-file.o qemu-file-buf.o qemu-file-unix.o qemu-file-stdio.o +common-obj-y += qemu-file.o qemu-file-unix.o qemu-file-stdio.o common-obj-y += xbzrle.o common-obj-$(CONFIG_RDMA) += rdma.o
migration/qemu-file-buf.c deleted +0 -462
462 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 31/46 migration: move definition of struct QEMUFile back into qemu-file.c
In reply to Daniel P. BerrangeNow that the memory buffer based QEMUFile impl is gone, there is no need for any backend to be accessing internals of the QEMUFile struct, so it can be moved back into qemu-file.c
--- migration/qemu-file-internal.h | 53 ------------------------------------------ migration/qemu-file-unix.c | 1 - migration/qemu-file.c | 23 +++++++++++++++++- 3 files changed, 22 insertions(+), 55 deletions(-) delete mode 100644 migration/qemu-file-internal.h
migration/qemu-file-internal.h deleted +0 -53
@@ -1,53 +0,0 @@ -/* -* QEMU System Emulator -* -* Copyright (c) 2003-2008 Fabrice Bellard -* -* 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. -*/ - -#ifndef QEMU_FILE_INTERNAL_H -#define QEMU_FILE_INTERNAL_H 1 - -#include "qemu-common.h" -#include "qemu/iov.h" - -#define IO_BUF_SIZE 32768 -#define MAX_IOV_SIZE MIN(IOV_MAX, 64) - -struct QEMUFile { -const QEMUFileOps *ops; -void *opaque; - -int64_t bytes_xfer; -int64_t xfer_limit; - -int64_t pos;/* start of buffer when writing, end of buffer -when reading */ -int buf_index; -int buf_size;/* 0 when writing */ -uint8_t buf[IO_BUF_SIZE ]; - -struct iovec iov[MAX_IOV_SIZE ]; -unsigned int iovcnt; - -int last_error; -}; - -#endif
migration/qemu-file-unix.c +0 -1
@@ -26,7 +26,6 @@#include "qemu/sockets.h" #include "qemu/coroutine.h" #include "migration/qemu-file.h" -#include "migration/qemu-file-internal.h" typedef struct QEMUFileSocket { int fd;
migration/qemu-file.c +22 -1
@@ -29,9 +29,30 @@#include "qemu/coroutine.h" #include "migration/migration.h" #include "migration/qemu-file.h" -#include "migration/qemu-file-internal.h" #include "trace.h" +#define IO_BUF_SIZE 32768 +#define MAX_IOV_SIZE MIN(IOV_MAX, 64) + +struct QEMUFile { +const QEMUFileOps *ops; +void *opaque; + +int64_t bytes_xfer; +int64_t xfer_limit; + +int64_t pos;/* start of buffer when writing, end of buffer +when reading */ +int buf_index; +int buf_size;/* 0 when writing */ +uint8_t buf[IO_BUF_SIZE ]; + +struct iovec iov[MAX_IOV_SIZE ]; +unsigned int iovcnt; + +int last_error; +}; +/* * Stop a file from being read/written - not all backing files can do this * typically only sockets can.
Signature · 1 line
2.4.3
PATCH 32/46 migration: split migration hooks out of QEMUFileOps
In reply to Daniel P. BerrangeThe QEMUFileOps struct contains the I/O subsystem callbacks and the migration stage hooks. Split the hooks out into a separate QEMUFileHooks struct to make it easier to refactor the I/O side of QEMUFile without affecting the hooks.
--- include/migration/qemu-file.h | 8 ++++++-- migration/qemu-file.c | 25 ++++++++++++++++--------- migration/rdma.c | 8 ++++++++ 3 files changed, 30 insertions(+), 11 deletions(-)
include/migration/qemu-file.h +6 -2
@@ -102,12 +102,15 @@ typedef struct QEMUFileOps {QEMUFileCloseFunc *close;QEMUFileGetFD *get_fd;QEMUFileWritevBufferFunc *writev_buffer; +QEMUFileShutdownFunc *shut_down; +} QEMUFileOps; + +typedef struct QEMUFileHooks {QEMURamHookFunc *before_ram_iterate;QEMURamHookFunc *after_ram_iterate;QEMURamHookFunc *hook_ram_load;QEMURamSaveFunc *save_page; -QEMUFileShutdownFunc *shut_down; -} QEMUFileOps; +}QEMUFileHooks ;struct QEMUSizedBuffer {struct iovec *iov;
@@ -121,6 +124,7 @@ QEMUFile *qemu_fopen(const char *filename, const char *mode);QEMUFile *qemu_fdopen (int fd,const char *mode);QEMUFile *qemu_fopen_socket (int fd,const char *mode);QEMUFile *qemu_popen_cmd (const char *command,const char *mode); +void qemu_file_set_hooks (QEMUFile *f,const QEMUFileHooks *hooks);int qemu_get_fd (QEMUFile *f);int qemu_fclose (QEMUFile *f);int64_t qemu_ftell (QEMUFile *f);
migration/qemu-file.c +16 -9
@@ -36,6 +36,7 @@struct QEMUFile {const QEMUFileOps *ops; +const QEMUFileHooks *hooks;void *opaque;int64_t bytes_xfer;
@@ -88,6 +89,12 @@ QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)return f; } + +void qemu_file_set_hooks (QEMUFile *f,const QEMUFileHooks *hooks) +{ + f->hooks = hooks; +} +/* * Get last error for stream f *
@@ -149,8 +156,8 @@ void ram_control_before_iterate(QEMUFile *f, uint64_t flags) {int ret =0 ; -if (f->ops->before_ram_iterate) { - ret = f->ops->before_ram_iterate (f, f->opaque, flags,NULL ); +if (f->hooks && f->hooks->before_ram_iterate) { + ret = f->hooks->before_ram_iterate (f, f->opaque, flags,NULL );if (ret <0 ) {qemu_file_set_error (f, ret); }
@@ -161,8 +168,8 @@ void ram_control_after_iterate(QEMUFile *f, uint64_t flags) {int ret =0 ; -if (f->ops->after_ram_iterate) { - ret = f->ops->after_ram_iterate (f, f->opaque, flags,NULL ); +if (f->hooks && f->hooks->after_ram_iterate) { + ret = f->hooks->after_ram_iterate (f, f->opaque, flags,NULL );if (ret <0 ) {qemu_file_set_error (f, ret); }
@@ -173,8 +180,8 @@ void ram_control_load_hook(QEMUFile *f, uint64_t flags, void *data) {int ret = -EINVAL ; -if (f->ops->hook_ram_load) { - ret = f->ops->hook_ram_load (f, f->opaque, flags, data); +if (f->hooks && f->hooks->hook_ram_load) { + ret = f->hooks->hook_ram_load (f, f->opaque, flags, data);if (ret <0 ) {qemu_file_set_error (f, ret); }
@@ -193,9 +200,9 @@ size_t ram_control_save_page(QEMUFile *f, ram_addr_t block_offset, ram_addr_t offset, size_t size, uint64_t *bytes_sent) { - if (f->ops->save_page) { - int ret = f->ops->save_page(f, f->opaque, block_offset, - offset, size, bytes_sent); + if (f->hooks && f->hooks->save_page) { + int ret = f->hooks->save_page(f, f->opaque, block_offset, + offset, size, bytes_sent);if (ret !=RAM_SAVE_CONTROL_DELAYED ) {if (bytes_sent && *bytes_sent >0 ) {
migration/rdma.c +8 -0
@@ -3380,12 +3380,18 @@ static const QEMUFileOps rdma_read_ops = { .get_buffer = qemu_rdma_get_buffer, .get_fd = qemu_rdma_get_fd, .close = qemu_rdma_close, +}; + +static const QEMUFileHooks rdma_read_hooks = { .hook_ram_load = rdma_load_hook, };static const QEMUFileOps rdma_write_ops = { .put_buffer = qemu_rdma_put_buffer, .close = qemu_rdma_close, +}; + +static const QEMUFileHooks rdma_write_hooks = { .before_ram_iterate = qemu_rdma_registration_start, .after_ram_iterate = qemu_rdma_registration_stop, .save_page = qemu_rdma_save_page,
@@ -3404,8 +3410,10 @@ static void *qemu_fopen_rdma(RDMAContext *rdma, const char *mode)if (mode[0 ] =='w' ) { r->file =qemu_fopen_ops (r, &rdma_write_ops); +qemu_file_set_hooks (r->file, &rdma_write_hooks); }else { r->file =qemu_fopen_ops (r, &rdma_read_ops); +qemu_file_set_hooks (r->file, &rdma_read_hooks); }return r->file;
Signature · 1 line
2.4.3
PATCH 33/46 migration: ensure qemu_fflush() always writes full data amount
In reply to Daniel P. BerrangeThe QEMUFile writev_buffer / put_buffer functions are expected to write out the full set of requested data, blocking until complete. The qemu_fflush() caller does not expect to deal with partial writes. Clarify the function comments and add a sanity check to the code to catch mistaken implementations.
--- include/migration/qemu-file.h | 6 ++++-- migration/qemu-file.c | 16 ++++++++++++---- 2 files changed, 16 insertions(+), 6 deletions(-)
include/migration/qemu-file.h +4 -2
@@ -29,7 +29,8 @@/* This function writes a chunk of data to a file at the given position. * The pos argument can be ignored if the file is only being used for -* streaming. The handler should try to write all of the data it can. +* streaming. The handler must write all of the data or return a negative +* errno value. */ typedef int (QEMUFilePutBufferFunc )(void *opaque,const uint8_t *buf,int64_t pos,int size);
@@ -55,7 +56,8 @@ typedef int (QEMUFileCloseFunc)(void *opaque);typedef int (QEMUFileGetFD )(void *opaque);/* -* This function writes an iovec to file. +* This function writes an iovec to file. The handler must write all +* of the data or return a negative errno value. */ typedef ssize_t (QEMUFileWritevBufferFunc )(void *opaque,struct iovec *iov,int iovcnt,int64_t pos);
migration/qemu-file.c +12 -4
@@ -123,11 +123,13 @@ bool qemu_file_is_writable(QEMUFile *f)* Flushes QEMUFile buffer * * If there is writev_buffer QEMUFileOps it uses it otherwise uses -* put_buffer ops. +* put_buffer ops. This will flush all pending data. If data was +* only partially flushed, it will set an error state. */ void qemu_fflush (QEMUFile *f) {ssize_t ret =0 ; +ssize_t expect =0 ;if (!qemu_file_is_writable (f)) {return ;
@@ -135,21 +137,27 @@ void qemu_fflush(QEMUFile *f)if (f->ops->writev_buffer) {if (f->iovcnt >0 ) { + expect =iov_size (f->iov, f->iovcnt); ret = f->ops->writev_buffer (f->opaque, f->iov, f->iovcnt, f->pos); } }else {if (f->buf_index >0 ) { + expect = f->buf_index; ret = f->ops->put_buffer (f->opaque, f->buf, f->pos, f->buf_index); } } +if (ret >=0 ) { f->pos += ret; } - f->buf_index =0 ; - f->iovcnt =0 ; -if (ret <0 ) { +/* We expect the QEMUFile write impl to send the full +* data set we requested, so sanity check that. +*/ +if (ret <0 || ret != expect) {qemu_file_set_error (f, ret); } + f->buf_index =0 ; + f->iovcnt =0 ; }void ram_control_before_iterate (QEMUFile *f,uint64_t flags)
Signature · 1 line
2.4.3
PATCH 34/46 migration: introduce qemu_fset_blocking function on QEMUFile
In reply to Daniel P. BerrangeRemove the assumption that every QEMUFile implementation has a file descriptor available by introducing a new function to change the blocking state of a QEMUFile.
Provide a default impl of the new method based on the get_fd method.
--- include/migration/qemu-file.h | 6 ++++++ migration/migration.c | 4 +--- migration/qemu-file.c | 15 +++++++++++++++ 3 files changed, 22 insertions(+), 3 deletions(-)
include/migration/qemu-file.h +6 -0
@@ -55,6 +55,10 @@ typedef int (QEMUFileCloseFunc)(void *opaque);*/ typedef int (QEMUFileGetFD )(void *opaque); +/* Called to change the blocking mode of the file +*/ +typedef int (QEMUFileSetBlocking )(void *opaque,bool enabled); +/* * This function writes an iovec to file. The handler must write all * of the data or return a negative errno value.
@@ -103,6 +107,7 @@ typedef struct QEMUFileOps {QEMUFileGetBufferFunc *get_buffer;QEMUFileCloseFunc *close;QEMUFileGetFD *get_fd; +QEMUFileSetBlocking *set_blocking;QEMUFileWritevBufferFunc *writev_buffer;QEMUFileShutdownFunc *shut_down; } QEMUFileOps;
@@ -128,6 +133,7 @@ QEMUFile *qemu_fopen_socket(int fd, const char *mode);QEMUFile *qemu_popen_cmd (const char *command,const char *mode);void qemu_file_set_hooks (QEMUFile *f,const QEMUFileHooks *hooks);int qemu_get_fd (QEMUFile *f); +int qemu_fset_blocking (QEMUFile *f,bool enabled);int qemu_fclose (QEMUFile *f);int64_t qemu_ftell (QEMUFile *f);int64_t qemu_ftell_fast (QEMUFile *f);
migration/migration.c +1 -3
@@ -317,11 +317,9 @@ static void process_incoming_migration_co(void *opaque)void process_incoming_migration (QEMUFile *f) {Coroutine *co =qemu_coroutine_create (process_incoming_migration_co); -int fd =qemu_get_fd (f); -assert (fd !=-1 );migrate_decompress_threads_create (); -qemu_set_nonblock (fd); +qemu_fset_blocking (f, false);qemu_coroutine_enter (co, f); }
migration/qemu-file.c +15 -0
@@ -270,6 +270,21 @@ int qemu_get_fd(QEMUFile *f)return -1 ; } +int qemu_fset_blocking (QEMUFile *f,bool enabled) +{ +if (f->ops->set_blocking) { +return f->ops->set_blocking (f->opaque, enabled); + }else if (f->ops->get_fd) { +int fd = f->ops->get_fd (f->opaque); +if (enabled) { +qemu_set_block (fd); + }else { +qemu_set_nonblock (fd); + } + } +return -1 ; +} +void qemu_update_position (QEMUFile *f,size_t size) { f->pos += size;
Signature · 1 line
2.4.3
PATCH 35/46 migration: force QEMUFile to blocking mode for outgoing migration
In reply to Daniel P. BerrangeInstead of relying on the default QEMUFile I/O blocking flag state, explicitly turn on blocking I/O for outgoing migration since it takes place in a background thread.
--- migration/migration.c | 1 + 1 file changed, 1 insertion(+)
migration/migration.c +1 -0
@@ -1034,6 +1034,7 @@ void migrate_fd_connect(MigrationState *s) s->expected_downtime = max_downtime/1000000 ; s->cleanup_bh =qemu_bh_new (migrate_fd_cleanup, s); +qemu_fset_blocking (s->file, true);qemu_file_set_rate_limit (s->file, s->bandwidth_limit /XFER_LIMIT_RATIO );
Signature · 1 line
2.4.3
PATCH 36/46 migration: introduce a new QEMUFile impl based on QIOChannel
In reply to Daniel P. BerrangeIntroduce a new QEMUFile implementation that is based on the QIOChannel objects. This impl is different from existing impls in that there is no file descriptor that can be made available, as some channels may be based on higher level protocols such as TLS.
The QIOChannel based implementation provides bi-directional streams from the start, so there's no mode flag provided when opening one.
--- include/migration/qemu-file.h | 4 + migration/Makefile.objs | 1 + migration/qemu-file-channel.c | 200 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 205 insertions(+) create mode 100644 migration/qemu-file-channel.c
include/migration/qemu-file.h +4 -0
@@ -23,7 +23,9 @@*/ #ifndef QEMU_FILE_H #define QEMU_FILE_H 1 +#include "qemu-common.h" #include "exec/cpu-common.h" +#include "io/channel.h" #include <stdint.h>
@@ -130,6 +132,8 @@ QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops);QEMUFile *qemu_fopen (const char *filename,const char *mode);QEMUFile *qemu_fdopen (int fd,const char *mode);QEMUFile *qemu_fopen_socket (int fd,const char *mode); +QEMUFile *qemu_fopen_channel_input (QIOChannel *ioc); +QEMUFile *qemu_fopen_channel_output (QIOChannel *ioc);QEMUFile *qemu_popen_cmd (const char *command,const char *mode);void qemu_file_set_hooks (QEMUFile *f,const QEMUFileHooks *hooks);int qemu_get_fd (QEMUFile *f);
migration/Makefile.objs +1 -0
@@ -1,6 +1,7 @@ common-obj-y += migration.o tcp.o common-obj-y += vmstate.o common-obj-y += qemu-file.o qemu-file-unix.o qemu-file-stdio.o +common-obj-y += qemu-file-channel.o common-obj-y += xbzrle.o common-obj-$(CONFIG_RDMA) += rdma.o
migration/qemu-file-channel.c new file +200 -0
200 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 37/46 migration: convert unix socket protocol to use QIOChannel
In reply to Daniel P. BerrangeConvert the unix socket migration protocol driver to use QIOChannel and QEMUFileChannel, instead of plain sockets APIs. It can be unconditionally built, since the socket impl of QIOChannel will report a suitable error on platforms where UNIX sockets are unavailable.
--- migration/Makefile.objs | 4 +- migration/migration.c | 4 ++ migration/unix.c | 103 +++++++++++++++++++++++++++++++----------------- 3 files changed, 72 insertions(+), 39 deletions(-)
migration/Makefile.objs +2 -2
@@ -1,11 +1,11 @@ -common-obj-y += migration.o tcp.o +common-obj-y += migration.o tcp.o unix.o common-obj-y += vmstate.o common-obj-y += qemu-file.o qemu-file-unix.o qemu-file-stdio.o common-obj-y += qemu-file-channel.o common-obj-y += xbzrle.o common-obj-$(CONFIG_RDMA) += rdma.o -common-obj-$(CONFIG_POSIX) += exec.o unix.o fd.o +common-obj-$(CONFIG_POSIX) += exec.o fd.o common-obj-y += block.o
migration/migration.c +4 -0
@@ -256,8 +256,10 @@ void qemu_start_incoming_migration(const char *uri, Error **errp)#if !defined(WIN32 ) } else if (strstart(uri, "exec:", &p)) {exec_start_incoming_migration (p, errp); +#endif }else if (strstart (uri,"unix:" , &p)) {unix_start_incoming_migration (p, errp); +#if !defined(WIN32 ) } else if (strstart(uri, "fd:", &p)) {fd_start_incoming_migration (p, errp);#endif
@@ -747,8 +749,10 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk,#if !defined(WIN32 ) } else if (strstart(uri, "exec:", &p)) {exec_start_outgoing_migration (s, p, &local_err); +#endif }else if (strstart (uri,"unix:" , &p)) {unix_start_outgoing_migration (s, p, &local_err); +#if !defined(WIN32 ) } else if (strstart(uri, "fd:", &p)) {fd_start_outgoing_migration (s, p, &local_err);#endif
migration/unix.c +66 -37
158 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 38/46 migration: convert tcp socket protocol to use QIOChannel
In reply to Daniel P. BerrangeConvert the tcp socket migration protocol driver to use QIOChannel and QEMUFileChannel, instead of plain sockets APIs.
While this now looks pretty similar to the migration/unix.c file from the previous patch, it was decided not to merge the two, because when TLS is added to the TCP impl later, this file diverge from unix.c once again.
--- migration/tcp.c | 119 ++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 82 insertions(+), 37 deletions(-)
migration/tcp.c +82 -37
@@ -2,9 +2,11 @@* QEMU live migration * * Copyright IBM, Corp. 2008 +* Copyright Red Hat, Inc. 2015 * * Authors: * Anthony Liguori <[email protected]> +* Daniel P. Berrange <[email protected]> * * This work is licensed under the terms of the GNU GPL, version 2. See * the COPYING file in the top-level directory.
@@ -17,11 +19,9 @@#include "qemu-common.h" #include "qemu/error-report.h" -#include "qemu/sockets.h" #include "migration/migration.h" #include "migration/qemu-file.h" -#include "block/block.h" -#include "qemu/main-loop.h" +#include "io/channel-socket.h" //#define DEBUG_MIGRATION_TCP
@@ -33,71 +33,116 @@ do { } while (0)#endif -static void tcp_wait_for_connect (int fd,Error *err,void *opaque) + +static SocketAddress *tcp_build_address (const char *host_port,Error **errp) +{ +InetSocketAddress *iaddr =inet_parse (host_port, errp); +SocketAddress *saddr; + +if (!iaddr) { +return NULL ; + } + + saddr =g_new0 (SocketAddress,1 ); + saddr->kind =SOCKET_ADDRESS_KIND_INET ; + saddr->inet = iaddr; + +return saddr; +} + + +static void tcp_outgoing_migration (Object *src, +Error *err, +gpointer opaque) {MigrationState *s = opaque; +QIOChannel *sioc =QIO_CHANNEL (src); -if (fd <0 ) { +if (err) {DPRINTF ("migrate connect error: %s\n" ,error_get_pretty (err)); s->file =NULL ;migrate_fd_error (s); }else {DPRINTF ("migrate connect success\n" ); - s->file =qemu_fopen_socket (fd,"wb" ); + s->file =qemu_fopen_channel_output (sioc);migrate_fd_connect (s); } +object_unref (src); } -void tcp_start_outgoing_migration (MigrationState *s,const char *host_port,Error **errp) + +void tcp_start_outgoing_migration (MigrationState *s, +const char *host_port, +Error **errp) { -inet_nonblocking_connect (host_port, tcp_wait_for_connect, s, errp); +SocketAddress *saddr =tcp_build_address (host_port, errp); +QIOChannelSocket *sioc; + +if (!saddr) { +return ; + } + + sioc =qio_channel_socket_new (); +qio_channel_socket_connect_async (sioc, + saddr, + tcp_outgoing_migration, + s, +NULL ); +qapi_free_SocketAddress (saddr); } -static void tcp_accept_incoming_migration (void *opaque) + +static gboolean tcp_accept_incoming_migration (QIOChannel *ioc, +GIOCondition condition, +gpointer opaque) { -struct sockaddr_in addr; -socklen_t addrlen =sizeof (addr); -int s = (intptr_t )opaque;QEMUFile *f; -int c, err; +QIOChannelSocket *cioc; +Error *err =NULL ; -do { - c =qemu_accept (s, (struct sockaddr *)&addr, &addrlen); - err =socket_error (); - }while (c <0 && err ==EINTR ); -qemu_set_fd_handler (s,NULL ,NULL ,NULL ); -closesocket (s); - -DPRINTF ("accepted migration\n" ); - -if (c <0 ) { + cioc =qio_channel_socket_accept (QIO_CHANNEL_SOCKET (ioc), + &err); +if (!cioc) {error_report ("could not accept migration connection (%s)" , -strerror (err)); -return ; - } - - f =qemu_fopen_socket (c,"rb" ); -if (f ==NULL ) { -error_report ("could not qemu_fopen socket" ); +error_get_pretty (err)); goto out; } +DPRINTF ("accepted migration\n" ); + + f =qemu_fopen_channel_input (QIO_CHANNEL (cioc)); +object_unref (OBJECT (cioc)); +process_incoming_migration (f); -return ; out: -closesocket (c); +/* Close listening socket as its no longer needed */ +qio_channel_close (ioc,NULL ); +return FALSE; } +void tcp_start_incoming_migration (const char *host_port,Error **errp) { -int s; +SocketAddress *saddr =tcp_build_address (host_port, errp); +QIOChannelSocket *listen_ioc; - s =inet_listen (host_port,NULL ,256 ,SOCK_STREAM ,0 , errp); -if (s <0 ) { +if (!saddr) {return ; } -qemu_set_fd_handler (s, tcp_accept_incoming_migration,NULL , - (void *)(intptr_t )s); + listen_ioc =qio_channel_socket_new (); +if (qio_channel_socket_listen_sync (listen_ioc, saddr, errp) <0 ) { +object_unref (OBJECT (listen_ioc)); +qapi_free_SocketAddress (saddr); +return ; + } + +qio_channel_add_watch (QIO_CHANNEL (listen_ioc), +G_IO_IN , + tcp_accept_incoming_migration, + listen_ioc, + (GDestroyNotify )object_unref); + +qapi_free_SocketAddress (saddr); }
Signature · 1 line
2.4.3
PATCH 39/46 migration: convert fd socket protocol to use QIOChannel
In reply to Daniel P. BerrangeConvert the fd socket migration protocol driver to use QIOChannel and QEMUFileChannel, instead of plain sockets APIs. It can be unconditionally built because the QIOChannel APIs it uses will take care to report suitable error messages if needed.
--- migration/Makefile.objs | 4 ++-- migration/fd.c | 57 ++++++++++++++++++++++++++++++++----------------- migration/migration.c | 4 ---- 3 files changed, 39 insertions(+), 26 deletions(-)
migration/Makefile.objs +2 -2
@@ -1,11 +1,11 @@ -common-obj-y += migration.o tcp.o unix.o +common-obj-y += migration.o tcp.o unix.o fd.o common-obj-y += vmstate.o common-obj-y += qemu-file.o qemu-file-unix.o qemu-file-stdio.o common-obj-y += qemu-file-channel.o common-obj-y += xbzrle.o common-obj-$(CONFIG_RDMA) += rdma.o -common-obj-$(CONFIG_POSIX) += exec.o fd.o +common-obj-$(CONFIG_POSIX) += exec.o common-obj-y += block.o
migration/fd.c +37 -20
99 lines not on this page · raw message
migration/migration.c +0 -4
@@ -259,10 +259,8 @@ void qemu_start_incoming_migration(const char *uri, Error **errp)#endif }else if (strstart (uri,"unix:" , &p)) {unix_start_incoming_migration (p, errp); -#if !defined(WIN32 ) }else if (strstart (uri,"fd:" , &p)) {fd_start_incoming_migration (p, errp); -#endif }else {error_setg (errp,"unknown migration protocol: %s" , uri); }
@@ -752,10 +750,8 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk,#endif }else if (strstart (uri,"unix:" , &p)) {unix_start_outgoing_migration (s, p, &local_err); -#if !defined(WIN32 ) }else if (strstart (uri,"fd:" , &p)) {fd_start_outgoing_migration (s, p, &local_err); -#endif }else {error_setg (errp,QERR_INVALID_PARAMETER_VALUE ,"uri" ,"a valid migration protocol" );
Signature · 1 line
2.4.3
PATCH 40/46 migration: convert exec socket protocol to use QIOChannel
In reply to Daniel P. BerrangeConvert the exec socket migration protocol driver to use QIOChannel and QEMUFileChannel, instead of the stdio popen APIs. It can be unconditionally built because the QIOChannelCommand class can report suitable error messages on platforms which can't fork processes.
--- migration/Makefile.objs | 3 +-- migration/exec.c | 48 ++++++++++++++++++++++++++++++------------------ migration/migration.c | 4 ---- 3 files changed, 31 insertions(+), 24 deletions(-)
migration/Makefile.objs +1 -2
@@ -1,11 +1,10 @@ -common-obj-y += migration.o tcp.o unix.o fd.o +common-obj-y += migration.o tcp.o unix.o fd.o exec.o common-obj-y += vmstate.o common-obj-y += qemu-file.o qemu-file-unix.o qemu-file-stdio.o common-obj-y += qemu-file-channel.o common-obj-y += xbzrle.o common-obj-$(CONFIG_RDMA) += rdma.o -common-obj-$(CONFIG_POSIX) += exec.o common-obj-y += block.o
migration/exec.c +30 -18
78 lines not on this page · raw message
migration/migration.c +0 -4
@@ -253,10 +253,8 @@ void qemu_start_incoming_migration(const char *uri, Error **errp) } else if (strstart(uri, "rdma:", &p)) {rdma_start_incoming_migration (p, errp);#endif -#if !defined(WIN32 ) }else if (strstart (uri,"exec:" , &p)) {exec_start_incoming_migration (p, errp); -#endif }else if (strstart (uri,"unix:" , &p)) {unix_start_incoming_migration (p, errp); }else if (strstart (uri,"fd:" , &p)) {
@@ -744,10 +742,8 @@ void qmp_migrate(const char *uri, bool has_blk, bool blk, } else if (strstart(uri, "rdma:", &p)) {rdma_start_outgoing_migration (s, p, &local_err);#endif -#if !defined(WIN32 ) }else if (strstart (uri,"exec:" , &p)) {exec_start_outgoing_migration (s, p, &local_err); -#endif }else if (strstart (uri,"unix:" , &p)) {unix_start_outgoing_migration (s, p, &local_err); }else if (strstart (uri,"fd:" , &p)) {
Signature · 1 line
2.4.3
PATCH 41/46 migration: convert RDMA to use QIOChannel interface
In reply to Daniel P. BerrangeThis converts the RDMA code to provide a subclass of QIOChannel that uses RDMA for the data transport.
The RDMA code would be much better off it it could be split up in a generic RDMA layer, a QIOChannel impl based on RMDA, and then the RMDA migration glue. This is left as a future exercise for the brave.
--- migration/rdma.c | 254 ++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 156 insertions(+), 98 deletions(-)
migration/rdma.c +156 -98
@@ -374,14 +374,19 @@ typedef struct RDMAContext {GHashTable *blockmap; } RDMAContext; -/* -* Interface to the rest of the migration call stack. -*/ -typedef struct QEMUFileRDMA { +#define TYPE_QIO_CHANNEL_RDMA "qio-channel-rdma" +#define QIO_CHANNEL_RDMA (obj) \ + OBJECT_CHECK(QIOChannelRDMA, (obj), TYPE_QIO_CHANNEL_RDMA) + +typedef struct QIOChannelRDMA QIOChannelRDMA ; + + +struct QIOChannelRDMA { +QIOChannel parent;RDMAContext *rdma; +QEMUFile *file;size_t len; -void *file; -}QEMUFileRDMA ; +};/* * Main structure for IB Send/Recv control messages.
@@ -2519,15 +2524,19 @@ static void *qemu_rdma_data_init(const char *host_port, Error **errp)* SEND messages for control only. * VM's ram is handled with regular RDMA messages. */ -static int qemu_rdma_put_buffer (void *opaque,const uint8_t *buf, -int64_t pos,int size) -{ -QEMUFileRDMA *r = opaque; -QEMUFile *f = r->file; -RDMAContext *rdma = r->rdma; -size_t remaining = size; -uint8_t * data = (void *) buf; +static ssize_t qio_channel_rdma_writev (QIOChannel *ioc, +const struct iovec *iov, +size_t niov, +int *fds, +size_t nfds, +Error **errp) +{ +QIOChannelRDMA *rioc =QIO_CHANNEL_RDMA (ioc); +QEMUFile *f = rioc->file; +RDMAContext *rdma = rioc->rdma;int ret; +ssize_t done =0 ; +size_t i;CHECK_ERROR_STATE ();
@@ -2541,26 +2550,31 @@ static int qemu_rdma_put_buffer(void *opaque, const uint8_t *buf,return ret; } -while (remaining) { -RDMAControlHeader head; +for (i =0 ; i < niov; i++) { +size_t remaining = iov[i].iov_len; +uint8_t * data = (void *)iov[i].iov_base; +while (remaining) { +RDMAControlHeader head; - r->len =MIN (remaining,RDMA_SEND_INCREMENT ); - remaining -= r->len; + rioc->len =MIN (remaining,RDMA_SEND_INCREMENT ); + remaining -= rioc->len; - head.len = r->len; - head.type =RDMA_CONTROL_QEMU_FILE ; + head.len = rioc->len; + head.type =RDMA_CONTROL_QEMU_FILE ; - ret =qemu_rdma_exchange_send (rdma, &head, data,NULL ,NULL ,NULL ); + ret =qemu_rdma_exchange_send (rdma, &head, data,NULL ,NULL ,NULL ); -if (ret <0 ) { - rdma->error_state = ret; -return ret; - } +if (ret <0 ) { + rdma->error_state = ret; +return ret; + } - data += r->len; + data += rioc->len; + done += rioc->len; + } } -return size; +return done; } static size_t qemu_rdma_fill(RDMAContext *rdma, uint8_t *buf,
@@ -2585,41 +2599,65 @@ static size_t qemu_rdma_fill(RDMAContext *rdma, uint8_t *buf,* RDMA links don't use bytestreams, so we have to * return bytes to QEMUFile opportunistically. */ -static int qemu_rdma_get_buffer (void *opaque,uint8_t *buf, -int64_t pos,int size) -{ -QEMUFileRDMA *r = opaque; -RDMAContext *rdma = r->rdma; +static ssize_t qio_channel_rdma_readv (QIOChannel *ioc, +const struct iovec *iov, +size_t niov, +int **fds, +size_t *nfds, +Error **errp) +{ +QIOChannelRDMA *rioc =QIO_CHANNEL_RDMA (ioc); +RDMAContext *rdma = rioc->rdma;RDMAControlHeader head;int ret =0 ; +ssize_t i; +size_t done =0 ;CHECK_ERROR_STATE (); -/* -* First, we hold on to the last SEND message we -* were given and dish out the bytes until we run -* out of bytes. -*/ - r->len =qemu_rdma_fill (r->rdma, buf, size,0 ); -if (r->len) { -return r->len; - } +for (i =0 ; i < niov; i++) { +size_t want = iov[i].iov_len; +uint8_t *data = (void *)iov[i].iov_base; -/* -* Once we run out, we block and wait for another -* SEND message to arrive. -*/ - ret =qemu_rdma_exchange_recv (rdma, &head,RDMA_CONTROL_QEMU_FILE ); +/* +* First, we hold on to the last SEND message we +* were given and dish out the bytes until we run +* out of bytes. +*/ + ret =qemu_rdma_fill (rioc->rdma, data, want,0 ); +if (ret >0 ) { + done += ret; +if (ret < want) { +break ; + }else { +continue ; + } + } -if (ret <0 ) { - rdma->error_state = ret; -return ret; - } +/* +* Once we run out, we block and wait for another +* SEND message to arrive. +*/ + ret =qemu_rdma_exchange_recv (rdma, &head,RDMA_CONTROL_QEMU_FILE ); -/* -* SEND was received with new bytes, now try again. -*/ -return qemu_rdma_fill (r->rdma, buf, size,0 ); +if (ret <0 ) { + rdma->error_state = ret; +return ret; + } + +/* +* SEND was received with new bytes, now try again. +*/ + ret =qemu_rdma_fill (rioc->rdma, data, want,0 ); +if (ret >0 ) { + done += ret; +if (ret < want) { +break ; + } + } + } + rioc->len = done; +return rioc->len; }/*
@@ -2646,15 +2684,16 @@ static int qemu_rdma_drain_cq(QEMUFile *f, RDMAContext *rdma)return 0 ; } -static int qemu_rdma_close (void *opaque) +static int qio_channel_rdma_close (QIOChannel *ioc, +Error **errp) { +QIOChannelRDMA *rioc =QIO_CHANNEL_RDMA (ioc);trace_qemu_rdma_close (); -QEMUFileRDMA *r = opaque; -if (r->rdma) { -qemu_rdma_cleanup (r->rdma); -g_free (r->rdma); +if (rioc->rdma) { +qemu_rdma_cleanup (rioc->rdma); +g_free (rioc->rdma); + rioc->rdma =NULL ; } -g_free (r);return 0 ; }
@@ -2696,8 +2735,8 @@ static size_t qemu_rdma_save_page(QEMUFile *f, void *opaque, ram_addr_t block_offset, ram_addr_t offset, size_t size, uint64_t *bytes_sent) { - QEMUFileRDMA *rfile = opaque; -RDMAContext *rdma = rfile->rdma; + QIOChannelRDMA *rioc = QIO_CHANNEL_RDMA(opaque); +RDMAContext *rdma = rioc->rdma;int ret;CHECK_ERROR_STATE ();
@@ -2951,8 +2990,8 @@ static int qemu_rdma_registration_handle(QEMUFile *f, void *opaque) };RDMAControlHeader blocks = { .type =RDMA_CONTROL_RAM_BLOCKS_RESULT , .repeat =1 }; -QEMUFileRDMA *rfile = opaque; -RDMAContext *rdma = rfile->rdma; +QIOChannelRDMA *rioc =QIO_CHANNEL_RDMA (opaque); +RDMAContext *rdma = rioc->rdma;RDMALocalBlocks *local = &rdma->local_ram_blocks;RDMAControlHeader head;RDMARegister *reg, *registers;
@@ -3207,9 +3246,9 @@ out:* We've already built our local RAMBlock list, but not yet sent the list to * the source. */ -static int rdma_block_notification_handle (QEMUFileRDMA *rfile,const char *name) +static int rdma_block_notification_handle (QIOChannelRDMA *rioc,const char *name) { -RDMAContext *rdma = rfile->rdma; +RDMAContext *rdma = rioc->rdma;int curr;int found =-1 ;
@@ -3251,8 +3290,8 @@ static int rdma_load_hook(QEMUFile *f, void *opaque, uint64_t flags, void *data)static int qemu_rdma_registration_start (QEMUFile *f,void *opaque,uint64_t flags,void *data) { -QEMUFileRDMA *rfile = opaque; -RDMAContext *rdma = rfile->rdma; +QIOChannelRDMA *rioc =QIO_CHANNEL_RDMA (opaque); +RDMAContext *rdma = rioc->rdma;CHECK_ERROR_STATE ();
@@ -3271,8 +3310,8 @@ static int qemu_rdma_registration_stop(QEMUFile *f, void *opaque, uint64_t flags, void *data) { Error *local_err = NULL, **errp = &local_err; -QEMUFileRDMA *rfile = opaque; -RDMAContext *rdma = rfile->rdma; +QIOChannelRDMA *rioc =QIO_CHANNEL_RDMA (opaque); +RDMAContext *rdma = rioc->rdma;RDMAControlHeader head = { .len =0 , .repeat =1 };int ret =0 ;
@@ -3368,55 +3407,74 @@ err:return ret; } -static int qemu_rdma_get_fd (void *opaque) -{ -QEMUFileRDMA *rfile = opaque; -RDMAContext *rdma = rfile->rdma; - -return rdma->comp_channel->fd; -} - -static const QEMUFileOps rdma_read_ops = { - .get_buffer = qemu_rdma_get_buffer, - .get_fd = qemu_rdma_get_fd, - .close = qemu_rdma_close, -}; -static const QEMUFileHooks rdma_read_hooks = { .hook_ram_load = rdma_load_hook, }; -static const QEMUFileOps rdma_write_ops = { - .put_buffer = qemu_rdma_put_buffer, - .close = qemu_rdma_close, -}; -static const QEMUFileHooks rdma_write_hooks = { .before_ram_iterate = qemu_rdma_registration_start, .after_ram_iterate = qemu_rdma_registration_stop, .save_page = qemu_rdma_save_page, }; -static void *qemu_fopen_rdma (RDMAContext *rdma,const char *mode) + +static void qio_channel_rdma_finalize (Object *obj) +{ +QIOChannelRDMA *rioc =QIO_CHANNEL_RDMA (obj); +if (rioc->rdma) { +qemu_rdma_cleanup (rioc->rdma); +g_free (rioc->rdma); + rioc->rdma =NULL ; + } +} + +static void qio_channel_rdma_class_init (ObjectClass *klass, + void *class_data G_GNUC_UNUSED) +{ +QIOChannelClass *ioc_klass =QIO_CHANNEL_CLASS (klass); + + ioc_klass->io_writev = qio_channel_rdma_writev; + ioc_klass->io_readv = qio_channel_rdma_readv; +//ioc_klass->io_set_blocking = qio_channel_rdma_set_blocking; + ioc_klass->io_close = qio_channel_rdma_close; +//ioc_klass->io_create_watch = qio_channel_rdma_create_watch; +} + +static const TypeInfo qio_channel_rdma_info = { + .parent =TYPE_QIO_CHANNEL , + .name =TYPE_QIO_CHANNEL_RDMA , + .instance_size =sizeof (QIOChannelRDMA), + .instance_finalize = qio_channel_rdma_finalize, + .class_init = qio_channel_rdma_class_init, +}; + +static void qio_channel_rdma_register_types (void ) +{ +type_register_static (&qio_channel_rdma_info); +} + +type_init (qio_channel_rdma_register_types); + +static QEMUFile *qemu_fopen_rdma (RDMAContext *rdma,const char *mode) { -QEMUFileRDMA *r; +QIOChannelRDMA *rioc;if (qemu_file_mode_is_not_valid (mode)) {return NULL ; } - r =g_malloc0 (sizeof (QEMUFileRDMA)); - r->rdma = rdma; + rioc =QIO_CHANNEL_RDMA (object_new (TYPE_QIO_CHANNEL_RDMA )); + rioc->rdma = rdma;if (mode[0 ] =='w' ) { - r->file =qemu_fopen_ops (r, &rdma_write_ops); -qemu_file_set_hooks (r->file, &rdma_write_hooks); + rioc->file =qemu_fopen_channel_output (QIO_CHANNEL (rioc)); +qemu_file_set_hooks (rioc->file, &rdma_write_hooks); }else { - r->file =qemu_fopen_ops (r, &rdma_read_ops); -qemu_file_set_hooks (r->file, &rdma_read_hooks); + rioc->file =qemu_fopen_channel_input (QIO_CHANNEL (rioc)); +qemu_file_set_hooks (rioc->file, &rdma_read_hooks); } -return r->file; +return rioc->file; }static void rdma_accept_incoming_migration (void *opaque)
Signature · 1 line
2.4.3
PATCH 42/46 migration: convert savevm to use QIOChannel for writing to files
In reply to Daniel P. BerrangeConvert the exec savevm code to use QIOChannel and QEMUFileChannel, instead of the stdio APIs.
--- migration/savevm.c | 8 +++++--- tests/Makefile | 4 ++-- tests/test-vmstate.c | 11 ++++++++++- 3 files changed, 17 insertions(+), 6 deletions(-)
migration/savevm.c +5 -3
@@ -48,6 +48,7 @@#include "qemu/iov.h" #include "block/snapshot.h" #include "block/qapi.h" +#include "io/channel-file.h" #ifndef ETH_P_RARP
@@ -1389,6 +1390,7 @@ void hmp_savevm(Monitor *mon, const QDict *qdict)void qmp_xen_save_devices_state (const char *filename,Error **errp) {QEMUFile *f; +QIOChannelFile *ioc;int saved_vm_running;int ret;
@@ -1396,11 +1398,11 @@ void qmp_xen_save_devices_state(const char *filename, Error **errp)vm_stop (RUN_STATE_SAVE_VM );global_state_store_running (); - f =qemu_fopen (filename,"wb" ); -if (!f) { -error_setg_file_open (errp, errno, filename); + ioc =qio_channel_file_new_path (filename,O_WRONLY |O_CREAT ,0660 , errp); +if (!ioc) { goto the_end; } + f =qemu_fopen_channel_output (QIO_CHANNEL (ioc)); ret =qemu_save_device_state (f);qemu_fclose (f);if (ret <0 ) {
tests/Makefile +2 -2
@@ -321,8 +321,8 @@ tests/test-qdev-global-props$(EXESUF): tests/test-qdev-global-props.o \ $(test-qapi-obj-y) tests/test-vmstate$(EXESUF): tests/test-vmstate.o \ migration/vmstate.o migration/qemu-file.o \ - migration/qemu-file-unix.o qjson.o \ - $(test-qom-obj-y) + migration/qemu-file-channel.o qjson.o \ + $(test-io-obj-y) tests/test-qapi-types.c tests/test-qapi-types.h :\ $(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-types.py $(qapi-py)
tests/test-vmstate.c +10 -1
@@ -28,6 +28,7 @@#include "migration/migration.h" #include "migration/vmstate.h" #include "qemu/coroutine.h" +#include "io/channel-file.h" static char temp_file[] ="/tmp/vmst.test.XXXXXX" ;static int temp_fd;
@@ -48,11 +49,17 @@ void yield_until_fd_readable(int fd)static QEMUFile *open_test_file (bool write) {int fd =dup (temp_fd); +QIOChannel *ioc;lseek (fd,0 ,SEEK_SET );if (write) { g_assert_cmpint(ftruncate(fd, 0), ==, 0); } -return qemu_fdopen (fd, write ?"wb" :"rb" ); + ioc =QIO_CHANNEL (qio_channel_file_new_fd (fd)); +if (write) { +return qemu_fopen_channel_output (ioc); + }else { +return qemu_fopen_channel_input (ioc); + } }#define SUCCESS (val) \
@@ -468,6 +475,8 @@ int main(int argc, char **argv) { temp_fd =mkstemp (temp_file); +module_call_init (MODULE_INIT_QOM ); +g_test_init (&argc, &argv,NULL );g_test_add_func ("/vmstate/simple/primitive" , test_simple_primitive);g_test_add_func ("/vmstate/versioned/load/v1" , test_load_v1);
Signature · 1 line
2.4.3
PATCH 43/46 migration: delete QEMUFile sockets implementation
In reply to Daniel P. BerrangeNow that the tcp, unix and fd migration backends have converted to use the QIOChannel based QEMUFile, there is no user remaining for the sockets based QEMUFile impl and it can be deleted.
--- include/migration/qemu-file.h | 2 - migration/Makefile.objs | 2 +- migration/qemu-file-unix.c | 237 ------------------------------------------ 3 files changed, 1 insertion(+), 240 deletions(-) delete mode 100644 migration/qemu-file-unix.c
include/migration/qemu-file.h +0 -2
@@ -130,8 +130,6 @@ struct QEMUSizedBuffer {QEMUFile *qemu_fopen_ops (void *opaque,const QEMUFileOps *ops);QEMUFile *qemu_fopen (const char *filename,const char *mode); -QEMUFile *qemu_fdopen (int fd,const char *mode); -QEMUFile *qemu_fopen_socket (int fd,const char *mode);QEMUFile *qemu_fopen_channel_input (QIOChannel *ioc);QEMUFile *qemu_fopen_channel_output (QIOChannel *ioc);QEMUFile *qemu_popen_cmd (const char *command,const char *mode);
migration/Makefile.objs +1 -1
@@ -1,6 +1,6 @@ common-obj-y += migration.o tcp.o unix.o fd.o exec.o common-obj-y += vmstate.o -common-obj-y += qemu-file.o qemu-file-unix.o qemu-file-stdio.o +common-obj-y += qemu-file.o qemu-file-stdio.o common-obj-y += qemu-file-channel.o common-obj-y += xbzrle.o
migration/qemu-file-unix.c deleted +0 -237
237 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 44/46 migration: delete QEMUFile stdio implementation
In reply to Daniel P. BerrangeNow that the exec migration backend and savevm have converted to use the QIOChannel based QEMUFile, there is no user remaining for the stdio based QEMUFile impl and it can be deleted.
--- include/migration/qemu-file.h | 2 - migration/Makefile.objs | 2 +- migration/qemu-file-stdio.c | 194 ------------------------------------------ 3 files changed, 1 insertion(+), 197 deletions(-) delete mode 100644 migration/qemu-file-stdio.c
include/migration/qemu-file.h +0 -2
@@ -129,10 +129,8 @@ struct QEMUSizedBuffer { };QEMUFile *qemu_fopen_ops (void *opaque,const QEMUFileOps *ops); -QEMUFile *qemu_fopen (const char *filename,const char *mode);QEMUFile *qemu_fopen_channel_input (QIOChannel *ioc);QEMUFile *qemu_fopen_channel_output (QIOChannel *ioc); -QEMUFile *qemu_popen_cmd (const char *command,const char *mode);void qemu_file_set_hooks (QEMUFile *f,const QEMUFileHooks *hooks);int qemu_get_fd (QEMUFile *f);int qemu_fset_blocking (QEMUFile *f,bool enabled);
migration/Makefile.objs +1 -1
@@ -1,6 +1,6 @@ common-obj-y += migration.o tcp.o unix.o fd.o exec.o common-obj-y += vmstate.o -common-obj-y += qemu-file.o qemu-file-stdio.o +common-obj-y += qemu-file.o common-obj-y += qemu-file-channel.o common-obj-y += xbzrle.o
migration/qemu-file-stdio.c deleted +0 -194
194 lines not on this page · raw message
Signature · 1 line
2.4.3
PATCH 45/46 migration: support TLS encryption with TCP migration backend
In reply to Daniel P. BerrangeThis extends the TCP migration backend so that it can make use of QIOChannelTLS to provide transparent TLS encryption. To trigger enablement the URI on the incoming and outgoing sides should have 'tls-creds=ID' appended, eg
tcp:$HOST:$PORT,tls-creds=ID
where ID is the object identifier of a set of TLS credentials previously created using object_add / -object. There is not currently any support for checking the migration client certificate names against ACLs. This is pending a conversion of the ACL code to QOM.
There is no support for dynamically negotiating use of TLS between the incoming/outgoing side. Both sides must agree on use of TLS out of band and set the URI accordingly. In practice it is expected that the administrator will just turn on use of TLS on their hosts in the libvirt config and then libvirt will instruct QEMU to use TLS for migration.
--- migration/tcp.c | 273 +++++++++++++++++++++++++++++++++++++++++++++++++++++--- qemu-options.hx | 7 +- 2 files changed, 264 insertions(+), 16 deletions(-)
migration/tcp.c +259 -14
@@ -22,6 +22,8 @@#include "migration/migration.h" #include "migration/qemu-file.h" #include "io/channel-socket.h" +#include "io/channel-tls.h" +#include "crypto/tlscreds.h" //#define DEBUG_MIGRATION_TCP
@@ -33,6 +35,22 @@ do { } while (0)#endif +typedef struct { +MigrationState *s; +QCryptoTLSCreds *tlscreds; +char *hostname; +}TCPConnectData ; + +typedef struct { +MigrationState *s; +QCryptoTLSCreds *tlscreds; +}TCPListenData ; + +typedef struct { +MigrationState *s; +QIOChannel *ioc; +}TCPConnectTLSData ; +static SocketAddress *tcp_build_address (const char *host_port,Error **errp) {
@@ -51,21 +69,174 @@ static SocketAddress *tcp_build_address(const char *host_port, Error **errp) } +static void tcp_connect_data_free (gpointer opaque) +{ +TCPConnectData *data = opaque; +if (!data) { +return ; + } +g_free (data->hostname); +object_unref (OBJECT (data->tlscreds)); +g_free (data); +} + + +static void tcp_listen_data_free (gpointer opaque) +{ +TCPListenData *data = opaque; +if (!data) { +return ; + } +object_unref (OBJECT (data->tlscreds)); +g_free (data); +} + + +static void tcp_connect_tls_data_free (gpointer opaque) +{ +TCPConnectTLSData *data = opaque; +if (!data) { +return ; + } +object_unref (OBJECT (data->ioc)); +g_free (data); +} + + +static char *tcp_get_opt_str (const char *host_port, +const char *key) +{ +const char *offset, *end; + + offset =strstr (host_port, key); +if (!offset) { +return NULL ; + } + + offset +=strlen (key); +if (offset[0 ] !='=' ) { +return NULL ; + } + offset++; + end =strchr (offset,',' ); +if (end) { +return g_strndup (offset, end - offset); + }else { +return g_strdup (offset); + } +} + + +static QCryptoTLSCreds *tcp_get_tls_creds (const char *host_port, +bool is_listen, +Error **errp) +{ +char *credname =NULL ; +Object *creds; +QCryptoTLSCreds *ret; + + credname =tcp_get_opt_str (host_port,"tls-creds" ); +if (!credname) { +return NULL ; + } + + creds =object_resolve_path_component ( +object_get_objects_root (), credname); +if (!creds) { +error_setg (errp,"No TLS credentials with id '%s'" , + credname); + goto error; + } + ret = (QCryptoTLSCreds *)object_dynamic_cast ( + creds,TYPE_QCRYPTO_TLS_CREDS ); +if (!ret) { +error_setg (errp,"Object with id '%s' is not TLS credentials" , + credname); + goto error; + } +if (is_listen) { +if (ret->endpoint !=QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ) { +error_setg (errp,"%s" , +"Expected TLS credentials for server endpoint" ); + goto error; + } + }else { +if (ret->endpoint !=QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT ) { +error_setg (errp,"%s" , +"Expected TLS credentials for client endpoint" ); + goto error; + } + } + +g_free (credname); +object_ref (OBJECT (ret)); +return ret; + + error: +g_free (credname); +return NULL ; +} + + +static void tcp_outgoing_migration_tls (Object *src, +Error *err, +gpointer opaque) +{ +TCPConnectTLSData *data = opaque; +QIOChannel *ioc =QIO_CHANNEL (src); + +if (err) { +DPRINTF ("migrate connect TLS error: %s\n" ,error_get_pretty (err)); + data->s->file =NULL ; +migrate_fd_error (data->s); + }else { +DPRINTF ("migrate connect success\n" ); + data->s->file =qemu_fopen_channel_output (ioc); +migrate_fd_connect (data->s); + } +} + +static void tcp_outgoing_migration (Object *src,Error *err,gpointer opaque) { -MigrationState *s = opaque; +TCPConnectData *data = opaque;QIOChannel *sioc =QIO_CHANNEL (src);if (err) {DPRINTF ("migrate connect error: %s\n" ,error_get_pretty (err)); - s->file =NULL ; -migrate_fd_error (s); + data->s->file =NULL ; +migrate_fd_error (data->s); }else { -DPRINTF ("migrate connect success\n" ); - s->file =qemu_fopen_channel_output (sioc); -migrate_fd_connect (s); +if (data->tlscreds) { +Error *local_err =NULL ; +QIOChannelTLS *tioc =qio_channel_tls_new_client ( + sioc, data->tlscreds, data->hostname, + &local_err); +if (!tioc) { +DPRINTF ("migrate tls setup error: %s\n" , +error_get_pretty (local_err)); +error_free (local_err); + data->s->file =NULL ; +migrate_fd_error (data->s); + }else { +TCPConnectTLSData *tdata = +g_new0 (TCPConnectTLSData,1 ); +DPRINTF ("migrate connect tls handshake begin\n" ); + tdata->s = data->s; + tdata->ioc = sioc; +object_ref (OBJECT (sioc)); +qio_channel_tls_handshake (tioc, + tcp_outgoing_migration_tls, + tdata, + tcp_connect_tls_data_free); + } + }else { +DPRINTF ("migrate connect success\n" ); + data->s->file =qemu_fopen_channel_output (sioc); +migrate_fd_connect (data->s); + } }object_unref (src); }
@@ -77,21 +248,56 @@ void tcp_start_outgoing_migration(MigrationState *s, {SocketAddress *saddr =tcp_build_address (host_port, errp);QIOChannelSocket *sioc; +Error *local_err =NULL ; +QCryptoTLSCreds *creds; +TCPConnectData *data;if (!saddr) {return ; } + creds =tcp_get_tls_creds (host_port, false, errp); +if (local_err) { +error_propagate (errp, local_err); +qapi_free_SocketAddress (saddr); +return ; + } + + data =g_new0 (TCPConnectData,1 ); + data->s = s; +if (creds) { + data->hostname =g_strdup (saddr->inet->host); + data->tlscreds = creds; + } + sioc =qio_channel_socket_new ();qio_channel_socket_connect_async (sioc, saddr, tcp_outgoing_migration, - s, -NULL ); + data, + tcp_connect_data_free);qapi_free_SocketAddress (saddr); } +static void tcp_incoming_migration_tls (Object *src, +Error *err, +gpointer opaque) +{ +QIOChannel *ioc =QIO_CHANNEL (src); + +if (err) { +DPRINTF ("migrate listen TLS error: %s\n" ,error_get_pretty (err)); +object_unref (OBJECT (ioc)); + }else { +DPRINTF ("migrate listen success\n" ); +QEMUFile *f =qemu_fopen_channel_input (ioc); + +process_incoming_migration (f); + } +} + +static gboolean tcp_accept_incoming_migration (QIOChannel *ioc,GIOCondition condition,gpointer opaque)
@@ -99,6 +305,7 @@ static gboolean tcp_accept_incoming_migration(QIOChannel *ioc,QEMUFile *f;QIOChannelSocket *cioc;Error *err =NULL ; +TCPListenData *data = opaque; cioc =qio_channel_socket_accept (QIO_CHANNEL_SOCKET (ioc), &err);
@@ -108,16 +315,38 @@ static gboolean tcp_accept_incoming_migration(QIOChannel *ioc, goto out; } -DPRINTF ("accepted migration\n" ); +if (data->tlscreds) { +DPRINTF ("Starting client TLS\n" ); +QIOChannelTLS *tioc =qio_channel_tls_new_server ( +QIO_CHANNEL (cioc), data->tlscreds, +NULL ,/* XXX pass ACL name */ + &err); +object_unref (OBJECT (cioc)); +if (!tioc) { +DPRINTF ("migrate tls setup error: %s\n" , +error_get_pretty (err)); +error_free (err); + goto out; + }else { +DPRINTF ("migrate connect tls handshake begin\n" ); +qio_channel_tls_handshake (tioc, + tcp_incoming_migration_tls, +NULL , +NULL ); + } + }else { +DPRINTF ("accepted migration\n" ); - f =qemu_fopen_channel_input (QIO_CHANNEL (cioc)); -object_unref (OBJECT (cioc)); + f =qemu_fopen_channel_input (QIO_CHANNEL (cioc)); +object_unref (OBJECT (cioc)); -process_incoming_migration (f); +process_incoming_migration (f); + } out:/* Close listening socket as its no longer needed */ qio_channel_close (ioc,NULL ); +object_unref (OBJECT (ioc));return FALSE; }
@@ -126,23 +355,39 @@ void tcp_start_incoming_migration(const char *host_port, Error **errp) {SocketAddress *saddr =tcp_build_address (host_port, errp);QIOChannelSocket *listen_ioc; +TCPListenData *data; +Error *local_err =NULL ; +QCryptoTLSCreds *creds;if (!saddr) {return ; } + creds =tcp_get_tls_creds (host_port, true, &local_err); +if (local_err) { +error_propagate (errp, local_err); +qapi_free_SocketAddress (saddr); +return ; + } + listen_ioc =qio_channel_socket_new ();if (qio_channel_socket_listen_sync (listen_ioc, saddr, errp) <0 ) {object_unref (OBJECT (listen_ioc));qapi_free_SocketAddress (saddr); +object_unref (OBJECT (creds));return ; } + data =g_new0 (TCPListenData,1 ); +if (creds) { + data->tlscreds = creds; + } +qio_channel_add_watch (QIO_CHANNEL (listen_ioc),G_IO_IN , tcp_accept_incoming_migration, - listen_ioc, - (GDestroyNotify )object_unref); + data, + tcp_listen_data_free);qapi_free_SocketAddress (saddr); }
qemu-options.hx +5 -2
@@ -3299,7 +3299,7 @@ Set TB size. ETEXI DEF("incoming", HAS_ARG, QEMU_OPTION_incoming, \ - "-incoming tcp:[host]:port[,to=maxport][,ipv4][,ipv6]\n" \ + "-incoming tcp:[host]:port[,to=maxport][,ipv4][,ipv6][,tls-creds=ID]\n" \ "-incoming rdma:host:port[,ipv4][,ipv6]\n" \ "-incoming unix:socketpath\n" \ " prepare for incoming migration, listen on\n" \
@@ -3312,11 +3312,14 @@ DEF("incoming", HAS_ARG, QEMU_OPTION_incoming, \ " wait for the URI to be specified via migrate_incoming\n", QEMU_ARCH_ALL) STEXI -@item -incoming tcp:[@var{host}]:@var{port}[,to=@var{maxport}][,ipv4][,ipv6] +@item -incoming tcp:[@var{host}]:@var{port}[,to=@var{maxport}][,ipv4][,ipv6][,tls-creds=ID] @itemx -incoming rdma:@var{host}:@var{port}[,ipv4][,ipv6] @findex -incoming Prepare for incoming migration, listen on a given tcp port. +If the @var{tls-creds} parameter is specified, it should refer to the ID +of a TLS credentials object previously created with @var{-object}. + @item -incoming unix:@var{socketpath} Prepare for incoming migration, listen on a given unix socket.
Signature · 1 line
2.4.3
Re: [Qemu-devel] [PATCH FYI 45/46] migration: support TLS encryption with TCP migration backend
Quoted 6 lines · * Daniel P. Berrange ([email protected]) wrote:
This extends the TCP migration backend so that it can make use of QIOChannelTLS to provide transparent TLS encryption. To trigger enablement the URI on the incoming and outgoing sides should have 'tls-creds=ID' appended, eg
tcp:$HOST:$PORT,tls-creds=ID
What makes this tcp specifc? Would it work on any bidirectional transport?
Dave
Quoted 420 lines
where ID is the object identifier of a set of TLS credentials previously created using
object_add/ -object. There is not currently any support for checking the migration client certificate names against ACLs. This is pending a conversion of the ACL code to QOM.There is no support for dynamically negotiating use of TLS between the incoming/outgoing side. Both sides must agree on use of TLS out of band and set the URI accordingly. In practice it is expected that the administrator will just turn on use of TLS on their hosts in the libvirt config and then libvirt will instruct QEMU to use TLS for migration.
Signed-off-by Daniel P. Berrange <[email protected]>--- migration/tcp.c | 273 +++++++++++++++++++++++++++++++++++++++++++++++++++++--- qemu-options.hx | 7 +- 2 files changed, 264 insertions(+), 16 deletions(-)migration/tcp.c +259
-14@@ -22,6 +22,8 @@#include "migration/migration.h" #include "migration/qemu-file.h" #include "io/channel-socket.h" +#include "io/channel-tls.h" +#include "crypto/tlscreds.h" //#define DEBUG_MIGRATION_TCP @@ -33,6 +35,22 @@ do { } while (0)#endif +typedef struct { +MigrationState *s; +QCryptoTLSCreds *tlscreds; +char *hostname; +}TCPConnectData ; + +typedef struct { +MigrationState *s; +QCryptoTLSCreds *tlscreds; +}TCPListenData ; + +typedef struct { +MigrationState *s; +QIOChannel *ioc; +}TCPConnectTLSData ; +static SocketAddress *tcp_build_address (const char *host_port,Error **errp) {@@ -51,21 +69,174 @@ static SocketAddress *tcp_build_address(const char *host_port, Error **errp) } +static void tcp_connect_data_free (gpointer opaque) +{ +TCPConnectData *data = opaque; +if (!data) { +return ; + } +g_free (data->hostname); +object_unref (OBJECT (data->tlscreds)); +g_free (data); +} + + +static void tcp_listen_data_free (gpointer opaque) +{ +TCPListenData *data = opaque; +if (!data) { +return ; + } +object_unref (OBJECT (data->tlscreds)); +g_free (data); +} + + +static void tcp_connect_tls_data_free (gpointer opaque) +{ +TCPConnectTLSData *data = opaque; +if (!data) { +return ; + } +object_unref (OBJECT (data->ioc)); +g_free (data); +} + + +static char *tcp_get_opt_str (const char *host_port, +const char *key) +{ +const char *offset, *end; + + offset =strstr (host_port, key); +if (!offset) { +return NULL ; + } + + offset +=strlen (key); +if (offset[0 ] !='=' ) { +return NULL ; + } + offset++; + end =strchr (offset,',' ); +if (end) { +return g_strndup (offset, end - offset); + }else { +return g_strdup (offset); + } +} + + +static QCryptoTLSCreds *tcp_get_tls_creds (const char *host_port, +bool is_listen, +Error **errp) +{ +char *credname =NULL ; +Object *creds; +QCryptoTLSCreds *ret; + + credname =tcp_get_opt_str (host_port,"tls-creds" ); +if (!credname) { +return NULL ; + } + + creds =object_resolve_path_component ( +object_get_objects_root (), credname); +if (!creds) { +error_setg (errp,"No TLS credentials with id '%s'" , + credname); + goto error; + } + ret = (QCryptoTLSCreds *)object_dynamic_cast ( + creds,TYPE_QCRYPTO_TLS_CREDS ); +if (!ret) { +error_setg (errp,"Object with id '%s' is not TLS credentials" , + credname); + goto error; + } +if (is_listen) { +if (ret->endpoint !=QCRYPTO_TLS_CREDS_ENDPOINT_SERVER ) { +error_setg (errp,"%s" , +"Expected TLS credentials for server endpoint" ); + goto error; + } + }else { +if (ret->endpoint !=QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT ) { +error_setg (errp,"%s" , +"Expected TLS credentials for client endpoint" ); + goto error; + } + } + +g_free (credname); +object_ref (OBJECT (ret)); +return ret; + + error: +g_free (credname); +return NULL ; +} + + +static void tcp_outgoing_migration_tls (Object *src, +Error *err, +gpointer opaque) +{ +TCPConnectTLSData *data = opaque; +QIOChannel *ioc =QIO_CHANNEL (src); + +if (err) { +DPRINTF ("migrate connect TLS error: %s\n" ,error_get_pretty (err)); + data->s->file =NULL ; +migrate_fd_error (data->s); + }else { +DPRINTF ("migrate connect success\n" ); + data->s->file =qemu_fopen_channel_output (ioc); +migrate_fd_connect (data->s); + } +} + +static void tcp_outgoing_migration (Object *src,Error *err,gpointer opaque) { -MigrationState *s = opaque; +TCPConnectData *data = opaque;QIOChannel *sioc =QIO_CHANNEL (src);if (err) {DPRINTF ("migrate connect error: %s\n" ,error_get_pretty (err)); - s->file =NULL ; -migrate_fd_error (s); + data->s->file =NULL ; +migrate_fd_error (data->s); }else { -DPRINTF ("migrate connect success\n" ); - s->file =qemu_fopen_channel_output (sioc); -migrate_fd_connect (s); +if (data->tlscreds) { +Error *local_err =NULL ; +QIOChannelTLS *tioc =qio_channel_tls_new_client ( + sioc, data->tlscreds, data->hostname, + &local_err); +if (!tioc) { +DPRINTF ("migrate tls setup error: %s\n" , +error_get_pretty (local_err)); +error_free (local_err); + data->s->file =NULL ; +migrate_fd_error (data->s); + }else { +TCPConnectTLSData *tdata = +g_new0 (TCPConnectTLSData,1 ); +DPRINTF ("migrate connect tls handshake begin\n" ); + tdata->s = data->s; + tdata->ioc = sioc; +object_ref (OBJECT (sioc)); +qio_channel_tls_handshake (tioc, + tcp_outgoing_migration_tls, + tdata, + tcp_connect_tls_data_free); + } + }else { +DPRINTF ("migrate connect success\n" ); + data->s->file =qemu_fopen_channel_output (sioc); +migrate_fd_connect (data->s); + } }object_unref (src); }@@ -77,21 +248,56 @@ void tcp_start_outgoing_migration(MigrationState *s, {SocketAddress *saddr =tcp_build_address (host_port, errp);QIOChannelSocket *sioc; +Error *local_err =NULL ; +QCryptoTLSCreds *creds; +TCPConnectData *data;if (!saddr) {return ; } + creds =tcp_get_tls_creds (host_port, false, errp); +if (local_err) { +error_propagate (errp, local_err); +qapi_free_SocketAddress (saddr); +return ; + } + + data =g_new0 (TCPConnectData,1 ); + data->s = s; +if (creds) { + data->hostname =g_strdup (saddr->inet->host); + data->tlscreds = creds; + } + sioc =qio_channel_socket_new ();qio_channel_socket_connect_async (sioc, saddr, tcp_outgoing_migration, - s, -NULL ); + data, + tcp_connect_data_free);qapi_free_SocketAddress (saddr); } +static void tcp_incoming_migration_tls (Object *src, +Error *err, +gpointer opaque) +{ +QIOChannel *ioc =QIO_CHANNEL (src); + +if (err) { +DPRINTF ("migrate listen TLS error: %s\n" ,error_get_pretty (err)); +object_unref (OBJECT (ioc)); + }else { +DPRINTF ("migrate listen success\n" ); +QEMUFile *f =qemu_fopen_channel_input (ioc); + +process_incoming_migration (f); + } +} + +static gboolean tcp_accept_incoming_migration (QIOChannel *ioc,GIOCondition condition,gpointer opaque)@@ -99,6 +305,7 @@ static gboolean tcp_accept_incoming_migration(QIOChannel *ioc,QEMUFile *f;QIOChannelSocket *cioc;Error *err =NULL ; +TCPListenData *data = opaque; cioc =qio_channel_socket_accept (QIO_CHANNEL_SOCKET (ioc), &err);@@ -108,16 +315,38 @@ static gboolean tcp_accept_incoming_migration(QIOChannel *ioc, goto out; } -DPRINTF ("accepted migration\n" ); +if (data->tlscreds) { +DPRINTF ("Starting client TLS\n" ); +QIOChannelTLS *tioc =qio_channel_tls_new_server ( +QIO_CHANNEL (cioc), data->tlscreds, +NULL ,/* XXX pass ACL name */ + &err); +object_unref (OBJECT (cioc)); +if (!tioc) { +DPRINTF ("migrate tls setup error: %s\n" , +error_get_pretty (err)); +error_free (err); + goto out; + }else { +DPRINTF ("migrate connect tls handshake begin\n" ); +qio_channel_tls_handshake (tioc, + tcp_incoming_migration_tls, +NULL , +NULL ); + } + }else { +DPRINTF ("accepted migration\n" ); - f =qemu_fopen_channel_input (QIO_CHANNEL (cioc)); -object_unref (OBJECT (cioc)); + f =qemu_fopen_channel_input (QIO_CHANNEL (cioc)); +object_unref (OBJECT (cioc)); -process_incoming_migration (f); +process_incoming_migration (f); + } out:/* Close listening socket as its no longer needed */ qio_channel_close (ioc,NULL ); +object_unref (OBJECT (ioc));return FALSE; }@@ -126,23 +355,39 @@ void tcp_start_incoming_migration(const char *host_port, Error **errp) {SocketAddress *saddr =tcp_build_address (host_port, errp);QIOChannelSocket *listen_ioc; +TCPListenData *data; +Error *local_err =NULL ; +QCryptoTLSCreds *creds;if (!saddr) {return ; } + creds =tcp_get_tls_creds (host_port, true, &local_err); +if (local_err) { +error_propagate (errp, local_err); +qapi_free_SocketAddress (saddr); +return ; + } + listen_ioc =qio_channel_socket_new ();if (qio_channel_socket_listen_sync (listen_ioc, saddr, errp) <0 ) {object_unref (OBJECT (listen_ioc));qapi_free_SocketAddress (saddr); +object_unref (OBJECT (creds));return ; } + data =g_new0 (TCPListenData,1 ); +if (creds) { + data->tlscreds = creds; + } +qio_channel_add_watch (QIO_CHANNEL (listen_ioc),G_IO_IN , tcp_accept_incoming_migration, - listen_ioc, - (GDestroyNotify )object_unref); + data, + tcp_listen_data_free);qapi_free_SocketAddress (saddr); }qemu-options.hx +5
-2@@ -3299,7 +3299,7 @@ Set TB size. ETEXI DEF("incoming", HAS_ARG, QEMU_OPTION_incoming, \ - "-incoming tcp:[host]:port[,to=maxport][,ipv4][,ipv6]\n" \ + "-incoming tcp:[host]:port[,to=maxport][,ipv4][,ipv6][,tls-creds=ID]\n" \ "-incoming rdma:host:port[,ipv4][,ipv6]\n" \ "-incoming unix:socketpath\n" \ " prepare for incoming migration, listen on\n" \@@ -3312,11 +3312,14 @@ DEF("incoming", HAS_ARG, QEMU_OPTION_incoming, \ " wait for the URI to be specified via migrate_incoming\n", QEMU_ARCH_ALL) STEXI -@item -incoming tcp:[@var{host}]:@var{port}[,to=@var{maxport}][,ipv4][,ipv6] +@item -incoming tcp:[@var{host}]:@var{port}[,to=@var{maxport}][,ipv4][,ipv6][,tls-creds=ID] @itemx -incoming rdma:@var{host}:@var{port}[,ipv4][,ipv6] @findex -incoming Prepare for incoming migration, listen on a given tcp port. +If the @var{tls-creds} parameter is specified, it should refer to the ID +of a TLS credentials object previously created with @var{-object}. + @item -incoming unix:@var{socketpath} Prepare for incoming migration, listen on a given unix socket.Signature · 1 line
2.4.3
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
Re: [Qemu-devel] [PATCH FYI 45/46] migration: support TLS encryption with TCP migration backend
Quoted 10 lines · Dr. David Alan Gilbert
Quoted 6 lines · * Daniel P. Berrange ([email protected]) wrote:
This extends the TCP migration backend so that it can make use of QIOChannelTLS to provide transparent TLS encryption. To trigger enablement the URI on the incoming and outgoing sides should have 'tls-creds=ID' appended, eg
tcp:$HOST:$PORT,tls-creds=ID
What makes this tcp specifc? Would it work on any bidirectional transport?
TLS is capable of working on any bi-directional transport. When using x509 certificates with TLS though, the client would typically validate the server identity by comparing the hostname it connected to, with the hostname encoded in the server's x509 certificate. So if we want to enable use of TLS over a transport that isn't TCP, we'd need to figure out the policy around x509 certificate validation. This isn't neccessarily hard, but it would need someone to describe the usage scenario, so we can figure out what makes sense from the security POV.
Since I've not heard of anyone asking for TLS support on non-TCP transports, I figured it was fine to only plumb it into tcp: for migration for now and avoid these questions.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
PATCH 46/46 migration: remove support for non-iovec based write handlers
In reply to Daniel P. BerrangeAll the remaining QEMUFile implementations provide an iovec based write handler, so the put_buffer callback can be removed to simplify the code.
--- include/migration/qemu-file.h | 9 --------- migration/qemu-file.c | 36 ++++++++---------------------------- migration/savevm.c | 8 -------- 3 files changed, 8 insertions(+), 45 deletions(-)
include/migration/qemu-file.h +0 -9
@@ -29,14 +29,6 @@#include <stdint.h> -/* This function writes a chunk of data to a file at the given position. -* The pos argument can be ignored if the file is only being used for -* streaming. The handler must write all of the data or return a negative -* errno value. -*/ -typedef int (QEMUFilePutBufferFunc )(void *opaque,const uint8_t *buf, -int64_t pos,int size); -/* Read a chunk of data from a file at the given position. The pos argument * can be ignored if the file is only be used for streaming. The number of * bytes actually read should be returned.
@@ -105,7 +97,6 @@ typedef size_t (QEMURamSaveFunc)(QEMUFile *f, void *opaque,typedef int (QEMUFileShutdownFunc )(void *opaque,bool rd,bool wr); typedef struct QEMUFileOps { - QEMUFilePutBufferFunc *put_buffer; QEMUFileGetBufferFunc *get_buffer; QEMUFileCloseFunc *close; QEMUFileGetFD *get_fd;
migration/qemu-file.c +8 -28
@@ -116,7 +116,7 @@ void qemu_file_set_error(QEMUFile *f, int ret)bool qemu_file_is_writable (QEMUFile *f) { -return f->ops->writev_buffer || f->ops->put_buffer; +return f->ops->writev_buffer; }/**
@@ -135,16 +135,9 @@ void qemu_fflush(QEMUFile *f)return ; } -if (f->ops->writev_buffer) { -if (f->iovcnt >0 ) { - expect =iov_size (f->iov, f->iovcnt); - ret = f->ops->writev_buffer (f->opaque, f->iov, f->iovcnt, f->pos); - } - }else { -if (f->buf_index >0 ) { - expect = f->buf_index; - ret = f->ops->put_buffer (f->opaque, f->buf, f->pos, f->buf_index); - } +if (f->iovcnt >0 ) { + expect =iov_size (f->iov, f->iovcnt); + ret = f->ops->writev_buffer (f->opaque, f->iov, f->iovcnt, f->pos); }if (ret >=0 ) {
@@ -339,11 +332,6 @@ static void add_to_iovec(QEMUFile *f, const uint8_t *buf, int size)void qemu_put_buffer_async (QEMUFile *f,const uint8_t *buf,int size) { -if (!f->ops->writev_buffer) { -qemu_put_buffer (f, buf, size); -return ; - } -if (f->last_error) {return ; }
@@ -367,9 +355,7 @@ void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size) }memcpy (f->buf + f->buf_index, buf, l); f->bytes_xfer += l; -if (f->ops->writev_buffer) { -add_to_iovec (f, f->buf + f->buf_index, l); - } +add_to_iovec (f, f->buf + f->buf_index, l); f->buf_index += l;if (f->buf_index ==IO_BUF_SIZE ) {qemu_fflush (f);
@@ -390,9 +376,7 @@ void qemu_put_byte(QEMUFile *f, int v) f->buf[f->buf_index] = v; f->bytes_xfer++; -if (f->ops->writev_buffer) { -add_to_iovec (f, f->buf + f->buf_index,1 ); - } +add_to_iovec (f, f->buf + f->buf_index,1 ); f->buf_index++;if (f->buf_index ==IO_BUF_SIZE ) {qemu_fflush (f);
@@ -519,12 +503,8 @@ int64_t qemu_ftell_fast(QEMUFile *f)int64_t ret = f->pos;int i; -if (f->ops->writev_buffer) { -for (i =0 ; i < f->iovcnt; i++) { - ret += f->iov[i].iov_len; - } - }else { - ret += f->buf_index; +for (i =0 ; i < f->iovcnt; i++) { + ret += f->iov[i].iov_len; }return ret;
migration/savevm.c +0 -8
@@ -139,13 +139,6 @@ static ssize_t block_writev_buffer(void *opaque, struct iovec *iov, int iovcnt,return qiov.size; } -static int block_put_buffer (void *opaque,const uint8_t *buf, -int64_t pos,int size) -{ -bdrv_save_vmstate (opaque, buf, pos, size); -return size; -} -static int block_get_buffer (void *opaque,uint8_t *buf,int64_t pos,int size) {return bdrv_load_vmstate (opaque, buf, pos, size);
@@ -162,7 +155,6 @@ static const QEMUFileOps bdrv_read_ops = { };static const QEMUFileOps bdrv_write_ops = { - .put_buffer = block_put_buffer, .writev_buffer = block_writev_buffer, .close = bdrv_fclose };
Signature · 1 line
2.4.3