libvirt/tools/ssh-proxy/ssh-proxy.c

297 lines
6.7 KiB
C
Raw Normal View History

/*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* For given domain and port create a VSOCK socket and pass it onto STDOUT.
*/
#include <config.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/vm_sockets.h>
#include "internal.h"
#include "virsocket.h"
#include "virstring.h"
#include "virfile.h"
#include "datatypes.h"
#include "virgettext.h"
#include "virxml.h"
#define VIR_FROM_THIS VIR_FROM_NONE
#define SYS_ERROR(...) \
do { \
int err = errno; \
fprintf(stderr, "ERROR %s:%d : ", __FUNCTION__, __LINE__); \
fprintf(stderr, __VA_ARGS__); \
fprintf(stderr, " : %s\n", g_strerror(err)); \
fprintf(stderr, "\n"); \
} while (0)
#define ERROR(...) \
do { \
fprintf(stderr, "ERROR %s:%d : ", __FUNCTION__, __LINE__); \
fprintf(stderr, __VA_ARGS__); \
fprintf(stderr, "\n"); \
} while (0)
#define HOSTNAME_PREFIX "qemu"
#define QEMU_SYSTEM_URI "qemu:///system"
#define QEMU_SESSION_URI "qemu:///session"
static void
dummyErrorHandler(void *opaque G_GNUC_UNUSED,
virErrorPtr error G_GNUC_UNUSED)
{
}
static void
printUsage(const char *argv0)
{
const char *progname;
if (!(progname = strrchr(argv0, '/')))
progname = argv0;
else
progname++;
printf(_("\n"
"Usage:\n"
"%1$s hostname port\n"
"\n"
"Hostname should be in one of the following forms:\n"
"\n"
" qemu:system/$domname\t\tfor domains under qemu:///system\n"
" qemu:session/$domname\t\tfor domains under qemu:///session\n"
" qemu/$domname\t\t\ttries looking up $domname under system followed by session URI\n"),
progname);
}
static int
parseArgs(int argc,
char *argv[],
const char **uriRet,
const char **domname,
unsigned int *port)
{
const char *uri = NULL;
/* Accepted URIs are:
*
* qemu/virtualMachine
* qemu:system/virtualMachine
* qemu:session/virtualMachine
*
* The last two result in system or session connection URIs passed to
* virConnectOpen(), the first one tries to find the machine under system
* connection first, followed by session connection.
*/
if (argc != 3 ||
!(uri = STRSKIP(argv[1], HOSTNAME_PREFIX))) {
ERROR(_("Bad usage"));
printUsage(argv[0]);
return -1;
}
if (*uri == ':') {
const char *tmp = NULL;
uri++;
if ((tmp = STRSKIP(uri, "system"))) {
*uriRet = QEMU_SYSTEM_URI;
} else if ((tmp = STRSKIP(uri, "session"))) {
*uriRet = QEMU_SESSION_URI;
} else {
ERROR(_("Unknown connection URI: '%1$s'"), uri);
printUsage(argv[0]);
return -1;
}
uri = tmp;
} else {
*uriRet = NULL;
}
if (!(*domname = STRSKIP(uri, "/")) ||
**domname == '\0') {
ERROR(_("Bad usage"));
printUsage(argv[0]);
return -1;
}
if (virStrToLong_ui(argv[2], NULL, 10, port) < 0) {
ERROR(_("Unable to parse port: %1$s"), argv[2]);
printUsage(argv[0]);
return -1;
}
return 0;
}
#define VSOCK_CID_XPATH "/domain/devices/vsock/cid"
static int
extractCID(virDomainPtr dom,
unsigned long long *cidRet)
{
g_autofree char *domxml = NULL;
g_autoptr(xmlDoc) doc = NULL;
g_autoptr(xmlXPathContext) ctxt = NULL;
g_autofree xmlNodePtr *nodes = NULL;
int nnodes = 0;
size_t i;
if (!(domxml = virDomainGetXMLDesc(dom, 0)))
return -1;
doc = virXMLParseStringCtxtWithIndent(domxml, "domain", &ctxt);
if (!doc)
return -1;
if ((nnodes = virXPathNodeSet(VSOCK_CID_XPATH, ctxt, &nodes)) < 0) {
return -1;
}
for (i = 0; i < nnodes; i++) {
unsigned long long cid;
if (virXMLPropULongLong(nodes[i], "address", 10, 0, &cid) > 0) {
*cidRet = cid;
return 0;
}
}
return -1;
}
#undef VSOCK_CID_XPATH
static int
lookupDomainAndFetchCID(const char *uri,
const char *domname,
unsigned long long *cid)
{
g_autoptr(virConnect) conn = NULL;
g_autoptr(virDomain) dom = NULL;
if (!(conn = virConnectOpenReadOnly(uri)))
return -1;
dom = virDomainLookupByName(conn, domname);
if (!dom)
dom = virDomainLookupByUUIDString(conn, domname);
if (!dom) {
int id;
if (virStrToLong_i(domname, NULL, 10, &id) >= 0)
dom = virDomainLookupByID(conn, id);
}
if (!dom)
return -1;
return extractCID(dom, cid);
}
static int
findDomain(const char *domname,
unsigned long long *cid)
{
const char *uris[] = {QEMU_SYSTEM_URI, QEMU_SESSION_URI};
const uid_t userid = geteuid();
size_t i;
for (i = 0; i < G_N_ELEMENTS(uris); i++) {
if (userid == 0 &&
STREQ(uris[i], "qemu:///session")) {
continue;
}
if (lookupDomainAndFetchCID(uris[i], domname, cid) >= 0)
return 0;
}
return -1;
}
static int
processVsock(const char *uri,
const char *domname,
unsigned int port)
{
struct sockaddr_vm sa = {
.svm_family = AF_VSOCK,
.svm_port = port,
};
VIR_AUTOCLOSE fd = -1;
unsigned long long cid = -1;
if (uri) {
lookupDomainAndFetchCID(uri, domname, &cid);
} else {
findDomain(domname, &cid);
}
if (cid == -1) {
ERROR(_("No usable vsock found"));
return -1;
}
sa.svm_cid = cid;
fd = socket(AF_VSOCK, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (fd < 0) {
SYS_ERROR(_("Failed to allocate AF_VSOCK socket"));
return -1;
}
if (connect(fd, (const struct sockaddr *)&sa, sizeof(sa)) < 0) {
SYS_ERROR(_("Failed to connect to vsock (cid=%1$llu port=%2$u)"),
cid, port);
return -1;
}
/* OpenSSH wants us to send a single byte along with the file descriptor,
* hence do so. */
if (virSocketSendFD(STDOUT_FILENO, fd) < 0) {
SYS_ERROR(_("Failed to send file descriptor %1$d"), fd);
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
const char *uri = NULL;
const char *domname = NULL;
unsigned int port;
if (virGettextInitialize() < 0)
return EXIT_FAILURE;
if (virInitialize() < 0) {
ERROR(_("Failed to initialize libvirt"));
return EXIT_FAILURE;
}
virSetErrorFunc(NULL, dummyErrorHandler);
if (parseArgs(argc, argv, &uri, &domname, &port) < 0)
return EXIT_FAILURE;
if (processVsock(uri, domname, port) < 0)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}