diff options
Diffstat (limited to 'src/network')
| -rw-r--r-- | src/network/networkctl.c | 532 |
1 files changed, 532 insertions, 0 deletions
diff --git a/src/network/networkctl.c b/src/network/networkctl.c new file mode 100644 index 0000000000..93b1293457 --- /dev/null +++ b/src/network/networkctl.c @@ -0,0 +1,532 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright 2014 Lennart Poettering + + systemd 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. + + systemd 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 systemd; If not, see <http://www.gnu.org/licenses/>. +***/ + +#include <stdbool.h> +#include <getopt.h> + +#include "sd-network.h" +#include "sd-rtnl.h" +#include "libudev.h" + +#include "build.h" +#include "util.h" +#include "pager.h" +#include "rtnl-util.h" +#include "udev-util.h" +#include "arphrd-list.h" +#include "local-addresses.h" + +static bool arg_no_pager = false; +static bool arg_legend = true; + +static void pager_open_if_enabled(void) { + + if (arg_no_pager) + return; + + pager_open(false); +} + +static int link_get_type_string(int iftype, struct udev_device *d, char **ret) { + const char *t; + char *p; + + if (iftype == ARPHRD_ETHER && d) { + const char *devtype, *id = NULL; + /* WLANs have iftype ARPHRD_ETHER, but we want + * to show a more useful type string for + * them */ + + devtype = udev_device_get_devtype(d); + if (streq_ptr(devtype, "wlan")) + id = "wlan"; + else if (streq_ptr(devtype, "wwan")) + id = "wwan"; + + if (id) { + p = strdup(id); + if (!p) + return -ENOMEM; + + *ret = p; + return 1; + } + } + + t = arphrd_to_name(iftype); + if (!t) { + *ret = NULL; + return 0; + } + + p = strdup(t); + if (!p) + return -ENOMEM; + + ascii_strlower(p); + *ret = p; + + return 0; +} + +static int list_links(char **args, unsigned n) { + _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL; + _cleanup_udev_unref_ struct udev *udev = NULL; + _cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL; + sd_rtnl_message *i; + unsigned c = 0; + int r; + + pager_open_if_enabled(); + + r = sd_rtnl_open(&rtnl, 0); + if (r < 0) { + log_error("Failed to connect to netlink: %s", strerror(-r)); + return r; + } + + udev = udev_new(); + if (!udev) { + log_error("Failed to connect to udev: %m"); + return -errno; + } + + r = sd_rtnl_message_new_link(rtnl, &req, RTM_GETLINK, 0); + if (r < 0) + return rtnl_log_create_error(r); + + r = sd_rtnl_message_request_dump(req, true); + if (r < 0) + return rtnl_log_create_error(r); + + r = sd_rtnl_call(rtnl, req, 0, &reply); + if (r < 0) { + log_error("Failed to enumerate links: %s", strerror(-r)); + return r; + } + + if (arg_legend) + printf("%3s %-16s %-10s %-10s %-10s\n", "IDX", "LINK", "TYPE", "STATE", "OPERATIONAL"); + + for (i = reply; i; i = sd_rtnl_message_next(i)) { + _cleanup_free_ char *state = NULL, *operational_state = NULL; + _cleanup_udev_device_unref_ struct udev_device *d = NULL; + char devid[2 + DECIMAL_STR_MAX(int)]; + _cleanup_free_ char *t = NULL; + const char *name; + unsigned iftype; + uint16_t type; + int ifindex; + + r = sd_rtnl_message_get_type(i, &type); + if (r < 0) + return rtnl_log_parse_error(r); + + if (type != RTM_NEWLINK) + continue; + + r = sd_rtnl_message_link_get_ifindex(i, &ifindex); + if (r < 0) + return rtnl_log_parse_error(r); + + r = sd_rtnl_message_read_string(i, IFLA_IFNAME, &name); + if (r < 0) + return rtnl_log_parse_error(r); + + r = sd_rtnl_message_link_get_type(i, &iftype); + if (r < 0) + return rtnl_log_parse_error(r); + + sd_network_get_link_state(ifindex, &state); + sd_network_get_link_operational_state(ifindex, &operational_state); + + sprintf(devid, "n%i", ifindex); + d = udev_device_new_from_device_id(udev, devid); + + link_get_type_string(iftype, d, &t); + + printf("%3i %-16s %-10s %-10s %-10s\n", ifindex, name, strna(t), strna(state), strna(operational_state)); + c++; + } + + if (arg_legend) + printf("\n%u links listed.\n", c); + + return 0; +} + +static int dump_addresses(sd_rtnl *rtnl, const char *prefix, int ifindex) { + _cleanup_free_ struct local_address *local = NULL; + int r, n, i; + + n = local_addresses(rtnl, ifindex, &local); + if (n < 0) + return n; + + for (i = 0; i < n; i++) { + _cleanup_free_ char *pretty = NULL; + + r = in_addr_to_string(local[i].family, &local[i].address, &pretty); + if (r < 0) + return r; + + printf("%*s%s\n", + (int) strlen(prefix), + i == 0 ? prefix : "", + pretty); + } + + return 0; +} + +static void dump_list(const char *prefix, char **l) { + char **i; + + STRV_FOREACH(i, l) { + printf("%*s%s\n", + (int) strlen(prefix), + i == l ? prefix : "", + *i); + } +} + +static int link_status(char **args, unsigned n) { + _cleanup_udev_unref_ struct udev *udev = NULL; + _cleanup_rtnl_unref_ sd_rtnl *rtnl = NULL; + char **name; + int r; + + if (n <= 1) { + _cleanup_free_ char *operational_state = NULL; + + r = sd_network_get_operational_state(&operational_state); + if (r < 0) { + log_error("Failed to get operational state: %s", strerror(-r)); + return r; + } + + printf("State: %s\n", operational_state); + return 0; + } + + pager_open_if_enabled(); + + r = sd_rtnl_open(&rtnl, 0); + if (r < 0) { + log_error("Failed to connect to netlink: %s", strerror(-r)); + return r; + } + + udev = udev_new(); + if (!udev) { + log_error("Failed to connect to udev: %m"); + return -errno; + } + + STRV_FOREACH(name, args + 1) { + _cleanup_strv_free_ char **dns = NULL, **ntp = NULL; + _cleanup_free_ char *state = NULL, *operational_state = NULL; + _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL, *reply = NULL; + _cleanup_udev_device_unref_ struct udev_device *d = NULL; + const char *canonical_name = NULL; + char devid[2 + DECIMAL_STR_MAX(int)]; + int ifindex, canonical_ifindex; + _cleanup_free_ char *t = NULL; + const char *driver = NULL, *path = NULL, *vendor = NULL, *model = NULL; + struct ether_addr e; + unsigned iftype; + bool have_mac; + uint32_t mtu; + + if (name != args+1) + printf("\n"); + + if (safe_atoi(*name, &ifindex) >= 0 && ifindex > 0) + r = sd_rtnl_message_new_link(rtnl, &req, RTM_GETLINK, ifindex); + else { + r = sd_rtnl_message_new_link(rtnl, &req, RTM_GETLINK, 0); + if (r < 0) + return rtnl_log_create_error(r); + + r = sd_rtnl_message_append_string(req, IFLA_IFNAME, *name); + } + + if (r < 0) + return rtnl_log_create_error(r); + + r = sd_rtnl_call(rtnl, req, 0, &reply); + if (r < 0) { + log_error("Failed to query link: %s", strerror(-r)); + continue; + } + + r = sd_rtnl_message_link_get_ifindex(reply, &canonical_ifindex); + if (r < 0) + return rtnl_log_parse_error(r); + + r = sd_rtnl_message_read_string(reply, IFLA_IFNAME, &canonical_name); + if (r < 0) + return rtnl_log_parse_error(r); + + r = sd_rtnl_message_link_get_type(reply, &iftype); + if (r < 0) + return rtnl_log_parse_error(r); + + have_mac = sd_rtnl_message_read_ether_addr(reply, IFLA_ADDRESS, &e) >= 0; + + if (have_mac) { + const uint8_t *p; + bool all_zeroes = true; + + for (p = (uint8_t*) &e; p < (uint8_t*) &e + sizeof(e); p++) + if (*p != 0) { + all_zeroes = false; + break; + } + + if (all_zeroes) + have_mac = false; + } + + sd_rtnl_message_read_u32(reply, IFLA_MTU, &mtu); + + sd_network_get_link_state(canonical_ifindex, &state); + sd_network_get_link_operational_state(canonical_ifindex, &operational_state); + + sd_network_get_link_dns(canonical_ifindex, &dns); + sd_network_get_link_dns(canonical_ifindex, &ntp); + + sprintf(devid, "n%i", canonical_ifindex); + d = udev_device_new_from_device_id(udev, devid); + + link_get_type_string(iftype, d, &t); + + if (d) { + driver = udev_device_get_property_value(d, "ID_NET_DRIVER"); + path = udev_device_get_property_value(d, "ID_PATH"); + + vendor = udev_device_get_property_value(d, "ID_VENDOR_FROM_DATABASE"); + if (!vendor) + vendor = udev_device_get_property_value(d, "ID_VENDOR"); + + model = udev_device_get_property_value(d, "ID_MODEL_FROM_DATABASE"); + if (!model) + model = udev_device_get_property_value(d, "ID_MODEL"); + } + + printf("%i: %s\n", canonical_ifindex, canonical_name); + + printf(" Type: %s\n" + " State: %s (%s)\n", + strna(t), + strna(operational_state), + strna(state)); + + if (path) + printf(" Path: %s\n", path); + if (driver) + printf(" Driver: %s\n", driver); + if (vendor) + printf(" Vendor: %s\n", vendor); + if (model) + printf(" Model: %s\n", model); + + if (have_mac) { + _cleanup_free_ char *h = NULL; + + h = hexmem(&e, sizeof(e)); + if (!h) + return log_oom(); + + printf(" HW Address: %s\n", h); + } + + if (mtu > 0) + printf(" MTU: %u\n", mtu); + + dump_addresses(rtnl, " Address: ", canonical_ifindex); + + if (!strv_isempty(dns)) + dump_list(" DNS: ", dns); + if (!strv_isempty(ntp)) + dump_list(" NTP: ", ntp); + } + + return 0; +} + +static void help(void) { + printf("%s [OPTIONS...]\n\n" + "Query and control the networking subsystem.\n\n" + " -h --help Show this help\n" + " --version Show package version\n\n" + "Commands:\n" + " list List links\n" + " status LINK Show link status\n" + , program_invocation_short_name); +} + +static int parse_argv(int argc, char *argv[]) { + + enum { + ARG_VERSION = 0x100, + ARG_NO_PAGER, + ARG_NO_LEGEND, + }; + + static const struct option options[] = { + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, ARG_VERSION }, + { "no-pager", no_argument, NULL, ARG_NO_PAGER }, + { "no-legend", no_argument, NULL, ARG_NO_LEGEND }, + {} + }; + + int c; + + assert(argc >= 0); + assert(argv); + + while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) { + + switch (c) { + + case 'h': + help(); + return 0; + + case ARG_VERSION: + puts(PACKAGE_STRING); + puts(SYSTEMD_FEATURES); + return 0; + + case ARG_NO_PAGER: + arg_no_pager = true; + break; + + case ARG_NO_LEGEND: + arg_legend = false; + break; + + case '?': + return -EINVAL; + + default: + assert_not_reached("Unhandled option"); + } + } + + return 1; +} + +static int networkctl_main(int argc, char *argv[]) { + + static const struct { + const char* verb; + const enum { + MORE, + LESS, + EQUAL + } argc_cmp; + const int argc; + int (* const dispatch)(char **args, unsigned n); + } verbs[] = { + { "list", LESS, 1, list_links }, + { "status", MORE, 1, link_status }, + }; + + int left; + unsigned i; + + assert(argc >= 0); + assert(argv); + + left = argc - optind; + + if (left <= 0) + /* Special rule: no arguments means "list" */ + i = 0; + else { + if (streq(argv[optind], "help")) { + help(); + return 0; + } + + for (i = 0; i < ELEMENTSOF(verbs); i++) + if (streq(argv[optind], verbs[i].verb)) + break; + + if (i >= ELEMENTSOF(verbs)) { + log_error("Unknown operation %s", argv[optind]); + return -EINVAL; + } + } + + switch (verbs[i].argc_cmp) { + + case EQUAL: + if (left != verbs[i].argc) { + log_error("Invalid number of arguments."); + return -EINVAL; + } + + break; + + case MORE: + if (left < verbs[i].argc) { + log_error("Too few arguments."); + return -EINVAL; + } + + break; + + case LESS: + if (left > verbs[i].argc) { + log_error("Too many arguments."); + return -EINVAL; + } + + break; + + default: + assert_not_reached("Unknown comparison operator."); + } + + return verbs[i].dispatch(argv + optind, left); +} + +int main(int argc, char* argv[]) { + int r; + + log_parse_environment(); + log_open(); + + r = parse_argv(argc, argv); + if (r <= 0) + goto finish; + + r = networkctl_main(argc, argv); + +finish: + pager_close(); + + return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS; +} |