... in preparation for adding ipv6 host forwarding support.
New test: avocado run tests/acceptance/hostfwd.py
Signed-off-by: Doug Evans <d...@google.com>
---
Changes from v3:
- this patch renamed from 2/3 to 3/4
- call inet_parse_host_and_port from util/qemu-sockets.c
- added tests/acceptance/hostfwd.py
Changes from v2:
- nothing of consequence
Changes from v1:
- this patch is new in v2
- address parsing refactor split out, ipv4 changes here
- libslirp part is now upstream in libslirp repo
net/slirp.c | 164 ++++++++++++++++++++++--------------
tests/acceptance/hostfwd.py | 84 ++++++++++++++++++
2 files changed, 185 insertions(+), 63 deletions(-)
create mode 100644 tests/acceptance/hostfwd.py
diff --git a/net/slirp.c b/net/slirp.c
index be914c0be0..ee39014a71 100644
--- a/net/slirp.c
+++ b/net/slirp.c
@@ -631,15 +631,90 @@ static SlirpState *slirp_lookup(Monitor *mon, const char
*id)
}
}
+/*
+ * Parse a protocol name of the form "name<sep>".
+ * Valid protocols are "tcp" and "udp". An empty string means "tcp".
+ * Returns a pointer to the end of the parsed string on success, and stores
+ * the result in *is_udp.
+ * Otherwise returns NULL and stores the error in *errp.
+ */
+static const char *parse_protocol(const char *str, int sep, bool *is_udp,
+ Error **errp)
+{
+ char buf[10];
+ const char *p = str;
+
+ if (get_str_sep(buf, sizeof(buf), &p, sep) < 0) {
+ error_setg(errp, "Missing protocol name separator");
+ return NULL;
+ }
+
+ if (!strcmp(buf, "tcp") || buf[0] == '\0') {
+ *is_udp = false;
+ } else if (!strcmp(buf, "udp")) {
+ *is_udp = true;
+ } else {
+ error_setg(errp, "Bad protocol name");
+ return NULL;
+ }
+
+ return p;
+}
+
+/*
+ * Parse an ip address/port of the form "address:port<terminator>".
+ * An empty address means INADDR_ANY.
+ * Returns a pointer to the end of the parsed string on success, and stores
+ * the results in *addr, *port.
+ * Otherwise returns NULL and stores the error in *errp.
+ */
+static const char *parse_ip_addr_and_port(const char *str, int terminator,
+ struct in_addr *addr, int *port,
+ Error **errp)
+{
+ g_autofree char *addr_str = NULL;
+ g_autofree char *port_str = NULL;
+ bool is_v6;
+ const char *p = inet_parse_host_and_port(str, terminator, &addr_str,
+ &port_str, &is_v6, errp);
+
+ if (p == NULL) {
+ return NULL;
+ }
+
+ /* Ignore is_v6 for the moment, if inet_aton fails let it. */
+ if (addr_str[0] == '\0') {
+ addr->s_addr = INADDR_ANY;
+ } else if (!inet_aton(addr_str, addr)) {
+ error_setg(errp, "Bad address");
+ return NULL;
+ }
+
+ if (qemu_strtoi(port_str, NULL, 10, port) < 0 ||
+ *port < 0 || *port > 65535) {
+ error_setg(errp, "Bad port");
+ return NULL;
+ }
+
+ /*
+ * At this point "p" points to the terminator or trailing NUL if the
+ * terminator is not present.
+ */
+ if (*p) {
+ ++p;
+ }
+ return p;
+}
+
void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict)
{
- struct in_addr host_addr = { .s_addr = INADDR_ANY };
+ struct in_addr host_addr;
int host_port;
- char buf[256];
const char *src_str, *p;
SlirpState *s;
- int is_udp = 0;
+ bool is_udp;
int err;
+ Error *error = NULL;
const char *arg1 = qdict_get_str(qdict, "arg1");
const char *arg2 = qdict_get_try_str(qdict, "arg2");
@@ -654,30 +729,18 @@ void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict)
return;
}
+ g_assert(src_str != NULL);
p = src_str;
- if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
- goto fail_syntax;
- }
-
- if (!strcmp(buf, "tcp") || buf[0] == '\0') {
- is_udp = 0;
- } else if (!strcmp(buf, "udp")) {
- is_udp = 1;
- } else {
- goto fail_syntax;
- }
- if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
- goto fail_syntax;
- }
- if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
+ p = parse_protocol(p, ':', &is_udp, &error);
+ if (p == NULL) {
goto fail_syntax;
}
- if (qemu_strtoi(p, NULL, 10, &host_port)) {
+ if (parse_ip_addr_and_port(p, '\0', &host_addr, &host_port,
+ &error) == NULL) {
goto fail_syntax;
}
-
err = slirp_remove_hostfwd(s->slirp, is_udp, host_addr, host_port);
monitor_printf(mon, "host forwarding rule for %s %s\n", src_str,
@@ -685,65 +748,39 @@ void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict)
return;
fail_syntax:
- monitor_printf(mon, "invalid format\n");
+ monitor_printf(mon, "Invalid format: %s\n", error_get_pretty(error));
+ error_free(error);
}
static int slirp_hostfwd(SlirpState *s, const char *redir_str, Error **errp)
{
- struct in_addr host_addr = { .s_addr = INADDR_ANY };
- struct in_addr guest_addr = { .s_addr = 0 };
+ struct in_addr host_addr, guest_addr;
int host_port, guest_port;
const char *p;
- char buf[256];
- int is_udp;
- char *end;
- const char *fail_reason = "Unknown reason";
+ bool is_udp;
+ Error *error = NULL;
+ g_assert(redir_str != NULL);
p = redir_str;
- if (!p || get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
- fail_reason = "No : separators";
- goto fail_syntax;
- }
- if (!strcmp(buf, "tcp") || buf[0] == '\0') {
- is_udp = 0;
- } else if (!strcmp(buf, "udp")) {
- is_udp = 1;
- } else {
- fail_reason = "Bad protocol name";
- goto fail_syntax;
- }
- if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
- fail_reason = "Missing : separator";
- goto fail_syntax;
- }
- if (buf[0] != '\0' && !inet_aton(buf, &host_addr)) {
- fail_reason = "Bad host address";
+ p = parse_protocol(p, ':', &is_udp, &error);
+ if (p == NULL) {
goto fail_syntax;
}
- if (get_str_sep(buf, sizeof(buf), &p, '-') < 0) {
- fail_reason = "Bad host port separator";
- goto fail_syntax;
- }
- host_port = strtol(buf, &end, 0);
- if (*end != '\0' || host_port < 0 || host_port > 65535) {
- fail_reason = "Bad host port";
+ p = parse_ip_addr_and_port(p, '-', &host_addr, &host_port, &error);
+ if (p == NULL) {
+ error_prepend(&error, "For host address: ");
goto fail_syntax;
}
- if (get_str_sep(buf, sizeof(buf), &p, ':') < 0) {
- fail_reason = "Missing guest address";
+ if (parse_ip_addr_and_port(p, '\0', &guest_addr, &guest_port,
+ &error) == NULL) {
+ error_prepend(&error, "For guest address: ");
goto fail_syntax;
}
- if (buf[0] != '\0' && !inet_aton(buf, &guest_addr)) {
- fail_reason = "Bad guest address";
- goto fail_syntax;
- }
-
- guest_port = strtol(p, &end, 0);
- if (*end != '\0' || guest_port < 1 || guest_port > 65535) {
- fail_reason = "Bad guest port";
+ if (guest_port == 0) {
+ error_setg(&error, "For guest address: Bad port");
goto fail_syntax;
}
@@ -757,7 +794,8 @@ static int slirp_hostfwd(SlirpState *s, const char
*redir_str, Error **errp)
fail_syntax:
error_setg(errp, "Invalid host forwarding rule '%s' (%s)", redir_str,
- fail_reason);
+ error_get_pretty(error));
+ error_free(error);
return -1;
}
diff --git a/tests/acceptance/hostfwd.py b/tests/acceptance/hostfwd.py
new file mode 100644
index 0000000000..1eaa0371ba
--- /dev/null
+++ b/tests/acceptance/hostfwd.py
@@ -0,0 +1,84 @@
+# Hostfwd command tests
+#
+# Copyright 2021 Google LLC
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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 General Public License
+# for more details.
+
+
+from avocado_qemu import Test
+
+
+class Hostfwd(Test):
+ """
+ :avocado: tags=hostfwd
+ """
+ def hmc(self, cmd):
+ return self.vm.command('human-monitor-command', command_line=cmd)
+
+ def test_qmp_hostfwd_ipv4(self):
+ self.vm.add_args('-nodefaults',
+ '-netdev', 'user,id=vnet',
+ '-device', 'virtio-net,netdev=vnet')
+ self.vm.launch()
+ self.assertEquals(self.hmc('hostfwd_add vnet tcp::65022-:22'), '')
+ self.assertEquals(self.hmc('hostfwd_remove vnet tcp::65022'),
+ 'host forwarding rule for tcp::65022 removed\r\n')
+ self.assertEquals(self.hmc('hostfwd_add tcp::65022-:22'), '')
+ self.assertEquals(self.hmc('hostfwd_remove tcp::65022'),
+ 'host forwarding rule for tcp::65022 removed\r\n')
+ self.assertEquals(self.hmc('hostfwd_add udp::65042-:42'), '')
+ self.assertEquals(self.hmc('hostfwd_remove udp::65042'),
+ 'host forwarding rule for udp::65042 removed\r\n')
+
+ def test_qmp_hostfwd_ipv4_functional_errors(self):
+ """Verify handling of various kinds of errors given valid addresses."""
+ self.vm.add_args('-nodefaults',
+ '-netdev', 'user,id=vnet',
+ '-device', 'virtio-net,netdev=vnet')
+ self.vm.launch()
+ self.assertEquals(self.hmc('hostfwd_remove ::65022'),
+ 'host forwarding rule for ::65022 not found\r\n')
+ self.assertEquals(self.hmc('hostfwd_add udp::65042-:42'), '')
+ self.assertEquals(self.hmc('hostfwd_add udp::65042-:42'),
+ "Could not set up host forwarding rule
'udp::65042-:42'\r\n")
+ self.assertEquals(self.hmc('hostfwd_remove ::65042'),
+ 'host forwarding rule for ::65042 not found\r\n')
+ self.assertEquals(self.hmc('hostfwd_remove udp::65042'),
+ 'host forwarding rule for udp::65042 removed\r\n')
+ self.assertEquals(self.hmc('hostfwd_remove udp::65042'),
+ 'host forwarding rule for udp::65042 not found\r\n')
+
+ def test_qmp_hostfwd_ipv4_parsing_errors(self):
+ """Verify handling of various kinds of parsing errors."""
+ self.vm.add_args('-nodefaults',
+ '-netdev', 'user,id=vnet',
+ '-device', 'virtio-net,netdev=vnet')
+ self.vm.launch()
+ self.assertEquals(self.hmc('hostfwd_remove abc::42'),
+ 'Invalid format: Bad protocol name\r\n')
+ self.assertEquals(self.hmc('hostfwd_add abc::65022-:22'),
+ "Invalid host forwarding rule 'abc::65022-:22' (Bad
protocol name)\r\n")
+ self.assertEquals(self.hmc('hostfwd_add :a.b.c.d:66-:66'),
+ "Invalid host forwarding rule ':a.b.c.d:66-:66' (For
host address: Bad address)\r\n")
+ self.assertEquals(self.hmc('hostfwd_add ::66-a.b.c.d:66'),
+ "Invalid host forwarding rule '::66-a.b.c.d:66' (For
guest address: Bad address)\r\n")
+ self.assertEquals(self.hmc('hostfwd_add ::66666-:66666'),
+ "Invalid host forwarding rule '::66666-:66666' (For
host address: Bad port)\r\n")
+ self.assertEquals(self.hmc('hostfwd_add ::-1-foo'),
+ "Invalid host forwarding rule '::-1-foo' (For host
address: error parsing host:port ':')\r\n")
+ self.assertEquals(self.hmc('hostfwd_add ::66-foo'),
+ "Invalid host forwarding rule '::66-foo' (For guest
address: error parsing host:port 'foo')\r\n")
+ self.assertEquals(self.hmc('hostfwd_add ::66-:66666'),
+ "Invalid host forwarding rule '::66-:66666' (For
guest address: Bad port)\r\n")
+ self.assertEquals(self.hmc('hostfwd_add ::66-:-1'),
+ "Invalid host forwarding rule '::66-:-1' (For guest
address: Bad port)\r\n")
+ self.assertEquals(self.hmc('hostfwd_add ::66-:0'),
+ "Invalid host forwarding rule '::66-:0' (For guest
address: Bad port)\r\n")
--
2.30.0.617.g56c4b15f3c-goog
