libvirt/src/remote/meson.build
Daniel P. Berrangé dfad1b551d remote: introduce virt-ssh-helper binary
When accessing libvirtd over a SSH tunnel, the remote driver needs a way
to proxy the SSH input/output stream to a suitable libvirt daemon. This
is currently done by spawning netcat, pointing it to the libvirtd socket
path. This is problematic for a number of reasons:

 - The socket path varies according to the --prefix chosen at build
   time. The remote client is seeing the local prefix, but what we
   need is the remote prefix

 - The socket path varies according to remote env variables, such as
   the XDG_RUNTIME_DIR location. Again we see the local XDG_RUNTIME_DIR
   value, but what we need is the remote value (if any)

 - The remote driver doesn't know whether it must connect to the legacy
   libvirtd or the modular daemons, so must always assume legacy
   libvirtd for back-compat. This means we'll always end up using the
   virtproxyd daemon adding an extra hop in the RPC layer.

 - We can not able to autospawn the libvirtd daemon for session mode
   access

To address these problems this patch introduces the 'virtd-ssh-helper'
program which takes the URI for the remote driver as a CLI parameter.
It then figures out which daemon to connect to and its socket path,
using the same code that the remote driver client would on the remote
host's build of libvirt.

Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2020-09-09 16:46:22 +01:00

318 lines
7.1 KiB
Meson

remote_driver_sources = [
'remote_driver.c',
'remote_sockets.c',
]
remote_driver_generated = []
foreach name : [ 'remote', 'qemu', 'lxc' ]
client_bodies_h = '@0@_client_bodies.h'.format(name)
protocol_c = '@0@_protocol.c'.format(name)
protocol_h = '@0@_protocol.h'.format(name)
protocol_x = '@0@_protocol.x'.format(name)
remote_driver_generated += custom_target(
client_bodies_h,
input: protocol_x,
output: client_bodies_h,
command: [
gendispatch_prog, '--mode=client', name, name.to_upper(), '@INPUT@',
],
capture: true,
)
remote_driver_generated += custom_target(
protocol_h,
input: protocol_x,
output: protocol_h,
command: [
genprotocol_prog, rpcgen_prog, '-h', '@INPUT@', '@OUTPUT@',
],
)
remote_driver_generated += custom_target(
protocol_c,
input: protocol_x,
output: protocol_c,
command: [
genprotocol_prog, rpcgen_prog, '-c', '@INPUT@', '@OUTPUT@',
],
)
rpc_probe_files += files(protocol_x)
endforeach
remote_daemon_sources = files(
'remote_daemon.c',
'remote_daemon_config.c',
'remote_daemon_dispatch.c',
'remote_daemon_stream.c',
)
remote_daemon_generated = []
virt_ssh_helper_sources = files(
'remote_sockets.c',
'remote_ssh_helper.c',
)
virt_ssh_helper_dep = [
src_dep,
]
foreach name : [ 'remote', 'qemu', 'lxc' ]
protocol_x = '@0@_protocol.x'.format(name)
dispatch_h = '@0@_daemon_dispatch_stubs.h'.format(name)
remote_daemon_generated += custom_target(
dispatch_h,
input: protocol_x,
output: dispatch_h,
command: [
gendispatch_prog, '--mode=server', name, name.to_upper(), '@INPUT@',
],
capture: true,
)
endforeach
# libvirt_conf_files:
# Generate libvirtd and virtd template files that are used to generate
# daemon configuration files.
# Each entry is a dictionary with following items:
# * input: source config file (required)
# * libvirtd: libvirtd config output template file (required)
# * virtd: virtd config output template file (required)
libvirt_conf_files = [
{
'input':'libvirtd.conf.in',
'libvirtd':'libvirtd.conf.tmp',
'virtd':'virtd.conf.tmp',
},
{
'input':'libvirtd.aug.in',
'libvirtd':'libvirtd.aug.tmp',
'virtd':'virtd.aug.tmp',
},
{
'input':'test_libvirtd.aug.in',
'libvirtd':'test_libvirtd.aug.tmp',
'virtd':'test_virtd.aug.tmp',
},
]
foreach name : libvirt_conf_files
tmp = configure_file(
input: name['input'],
output: name['libvirtd'],
command: [ 'sed', '-e', '/[@]CUT_ENABLE_IP[@]/d', '-e', '/[@]END[@]/d', '@INPUT@' ],
capture: true,
)
set_variable(name['libvirtd'].underscorify(), tmp)
endforeach
foreach name : libvirt_conf_files
tmp = configure_file(
input: name['input'],
output: name['virtd'],
command: [ 'sed', '-e', '/[@]CUT_ENABLE_IP[@]/,/[@]END[@]/d', '@INPUT@' ],
capture: true,
)
set_variable(name['virtd'].underscorify(), tmp)
endforeach
libvirtd_socket_unit_files = [
'libvirtd.socket',
'libvirtd-ro.socket',
'libvirtd-admin.socket',
'libvirtd-tcp.socket',
'libvirtd-tls.socket',
]
libvirtd_socket_conflicts = ' '.join(libvirtd_socket_unit_files)
logrotate_files = [
'libvirtd.qemu',
'libvirtd.lxc',
'libvirtd.libxl',
'libvirtd',
]
if conf.has('WITH_REMOTE')
remote_driver_lib = static_library(
'virt_remote_driver',
[
remote_driver_sources,
remote_driver_generated,
],
dependencies: [
rpc_dep,
sasl_dep,
src_dep,
xdr_dep,
],
include_directories: [
conf_inc_dir,
],
)
check_protocols += {
'name': 'remote_protocol',
'lib': remote_driver_lib,
}
check_protocols += {
'name': 'qemu_protocol',
'lib': remote_driver_lib,
}
check_protocols += {
'name': 'lxc_protocol',
'lib': remote_driver_lib,
}
libvirt_libs += remote_driver_lib
if conf.has('WITH_LIBVIRTD')
guest_unit_files += files('virt-guest-shutdown.target')
virt_daemons += {
'name': 'libvirtd',
'c_args': [
'-DSOCK_PREFIX="libvirt"',
'-DDAEMON_NAME="libvirtd"',
'-DWITH_IP',
'-DLIBVIRTD',
],
}
virt_daemon_confs += {
'name': 'libvirtd',
'with_ip': true,
}
virt_daemon_units += {
'service': 'libvirtd',
'service_in': files('libvirtd.service.in'),
'name': 'Libvirt',
'sockprefix': 'libvirt',
'sockets': [ 'main', 'ro', 'admin', 'tcp', 'tls' ],
}
openrc_init_files += {
'name': 'libvirtd',
'in_file': files('libvirtd.init.in'),
'confd': files('libvirtd.confd'),
}
sysconf_files += {
'name': 'libvirtd',
'file': files('libvirtd.sysconf'),
}
virt_daemons += {
'name': 'virtproxyd',
'c_args': [
'-DSOCK_PREFIX="libvirt"',
'-DDAEMON_NAME="virtproxyd"',
'-DWITH_IP',
'-DVIRTPROXYD',
],
}
virt_daemon_confs += {
'name': 'virtproxyd',
'with_ip': true,
}
virt_daemon_units += {
'service': 'virtproxyd',
'service_in': files('virtproxyd.service.in'),
'name': 'Libvirt proxy',
'sockprefix': 'libvirt',
'sockets': [ 'main', 'ro', 'admin', 'tcp', 'tls' ],
'deps': libvirtd_socket_conflicts,
}
openrc_init_files += {
'name': 'virtproxyd',
'in_file': files('virtproxyd.init.in'),
'confd': files('virtproxyd.confd'),
}
sysconf_files += {
'name': 'virtproxyd',
'file': files('virtproxyd.sysconf'),
}
virt_install_dirs += [
localstatedir / 'log' / 'libvirt',
]
logrotate_conf = configuration_data()
logrotate_conf.set('localstatedir', localstatedir)
foreach name : logrotate_files
log_file = configure_file(
input: '@0@.logrotate.in'.format(name),
output: '@0@.logrotate'.format(name),
configuration: logrotate_conf,
)
install_data(
log_file,
install_dir: sysconfdir / 'logrotate.d',
rename: [ name ],
)
endforeach
if conf.has('WITH_SYSCTL')
# Use $(prefix)/lib rather than $(libdir), since man sysctl.d insists on
# /usr/lib/sysctl.d/ even when libdir is /usr/lib64
install_data(
'libvirtd.sysctl',
install_dir: prefix / 'lib' / 'sysctl.d',
rename: [ '60-libvirtd.conf' ],
)
endif
if conf.has('WITH_POLKIT')
polkitdir = datadir / 'polkit-1'
install_data(
'libvirtd.policy',
install_dir: polkitdir / 'actions',
rename: [ 'org.libvirt.unix.policy' ],
)
install_data(
'libvirtd.rules',
install_dir: polkitdir / 'rules.d',
rename: [ '50-libvirt.rules' ],
)
endif
virt_helpers += {
'name': 'virt-ssh-helper',
'sources': [
virt_ssh_helper_sources
],
'install_dir': bindir,
}
endif
endif
if conf.has('WITH_REMOTE')
used_sym_files += 'libvirt_remote.syms'
else
sym_files += 'libvirt_remote.syms'
endif
# This is needed for clients too, so can't wrap in
# the WITH_LIBVIRTD conditional
if conf.has('WITH_SASL')
install_data(
'libvirtd.sasl',
install_dir: sysconfdir / 'sasl2',
rename: [ 'libvirt.conf' ],
)
endif
remote_inc_dir = include_directories('.')