2020-07-18 10:49:22 +00:00
|
|
|
/*
|
|
|
|
* cmd/ifquery.c
|
|
|
|
* Purpose: look up information in /etc/network/interfaces
|
|
|
|
*
|
|
|
|
* Copyright (c) 2020 Ariadne Conill <ariadne@dereferenced.org>
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
|
* copyright notice and this permission notice appear in all copies.
|
|
|
|
*
|
|
|
|
* This software is provided 'as is' and without any warranty, express or
|
|
|
|
* implied. In no event shall the authors be liable for any damages arising
|
|
|
|
* from the use of this software.
|
|
|
|
*/
|
|
|
|
|
2020-07-18 23:44:58 +00:00
|
|
|
#define _GNU_SOURCE
|
2020-07-19 01:31:44 +00:00
|
|
|
#include <fnmatch.h>
|
2020-07-18 10:49:22 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
2020-07-18 23:44:58 +00:00
|
|
|
#include <getopt.h>
|
2020-07-18 10:49:22 +00:00
|
|
|
#include "libifupdown/libifupdown.h"
|
2020-07-24 09:07:19 +00:00
|
|
|
#include "cmd/multicall.h"
|
2020-07-18 10:49:22 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
print_interface(struct lif_interface *iface)
|
|
|
|
{
|
2020-07-28 19:46:25 +00:00
|
|
|
if (!lif_lifecycle_query_dependents(&exec_opts, iface, iface->ifname))
|
|
|
|
return;
|
|
|
|
|
2020-07-18 10:49:22 +00:00
|
|
|
if (iface->is_auto)
|
|
|
|
printf("auto %s\n", iface->ifname);
|
|
|
|
|
2020-07-24 11:00:49 +00:00
|
|
|
printf("iface %s\n", iface->ifname);
|
2020-07-18 10:49:22 +00:00
|
|
|
|
|
|
|
struct lif_node *iter;
|
|
|
|
LIF_DICT_FOREACH(iter, &iface->vars)
|
|
|
|
{
|
|
|
|
struct lif_dict_entry *entry = iter->data;
|
|
|
|
|
|
|
|
if (!strcmp(entry->key, "address"))
|
|
|
|
{
|
|
|
|
struct lif_address *addr = entry->data;
|
|
|
|
char addr_buf[512];
|
|
|
|
|
|
|
|
if (!lif_address_unparse(addr, addr_buf, sizeof addr_buf, true))
|
|
|
|
{
|
|
|
|
printf(" # warning: failed to unparse address\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf(" %s %s\n", entry->key, addr_buf);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
printf(" %s %s\n", entry->key, (const char *) entry->data);
|
|
|
|
}
|
2020-07-19 01:34:38 +00:00
|
|
|
|
|
|
|
printf("\n");
|
2020-07-18 10:49:22 +00:00
|
|
|
}
|
|
|
|
|
2020-07-24 10:25:06 +00:00
|
|
|
void
|
|
|
|
print_interface_dot(struct lif_dict *collection, struct lif_interface *iface, struct lif_interface *parent)
|
|
|
|
{
|
2020-08-04 18:36:38 +00:00
|
|
|
if (!lif_lifecycle_query_dependents(&exec_opts, iface, iface->ifname))
|
|
|
|
return;
|
|
|
|
|
2020-07-24 10:25:06 +00:00
|
|
|
if (iface->is_up)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (parent != NULL)
|
|
|
|
printf("\"%s\" -> ", parent->ifname);
|
|
|
|
|
|
|
|
printf("\"%s\"", iface->ifname);
|
|
|
|
|
|
|
|
printf("\n");
|
|
|
|
|
|
|
|
struct lif_dict_entry *entry = lif_dict_find(&iface->vars, "requires");
|
|
|
|
|
|
|
|
if (entry == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
char require_ifs[4096] = {};
|
|
|
|
strlcpy(require_ifs, entry->data, sizeof require_ifs);
|
|
|
|
char *reqp = require_ifs;
|
|
|
|
|
|
|
|
for (char *tokenp = lif_next_token(&reqp); *tokenp; tokenp = lif_next_token(&reqp))
|
|
|
|
{
|
|
|
|
struct lif_interface *child_if = lif_interface_collection_find(collection, tokenp);
|
|
|
|
|
|
|
|
print_interface_dot(collection, child_if, iface);
|
|
|
|
child_if->is_up = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-26 08:28:29 +00:00
|
|
|
static inline size_t
|
|
|
|
count_set_bits(const char *netmask)
|
|
|
|
{
|
|
|
|
/* netmask set to CIDR length */
|
|
|
|
if (strchr(netmask, '.') == NULL)
|
|
|
|
return strtol(netmask, NULL, 10);
|
|
|
|
|
|
|
|
size_t r = 0;
|
|
|
|
struct in_addr in;
|
|
|
|
|
|
|
|
if (inet_pton(AF_INET, netmask, &in) == 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
/* take the IP, put it in host endian order, and
|
|
|
|
* flip it so that all the set bits are set to the right.
|
|
|
|
* then we can simply count down from 32 and right-shift
|
|
|
|
* until the bit field is all zero.
|
|
|
|
*/
|
|
|
|
unsigned int bits = htonl(in.s_addr);
|
|
|
|
for (bits = ~bits, r = 32; bits; bits >>= 1, r--)
|
|
|
|
;
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
print_interface_property(struct lif_interface *iface, const char *property)
|
|
|
|
{
|
|
|
|
struct lif_node *iter;
|
|
|
|
bool printing_address = !strcmp(property, "address");
|
|
|
|
|
|
|
|
LIF_DICT_FOREACH(iter, &iface->vars)
|
|
|
|
{
|
|
|
|
struct lif_dict_entry *entry = iter->data;
|
|
|
|
|
|
|
|
if (strcmp(entry->key, property))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (printing_address)
|
|
|
|
{
|
|
|
|
struct lif_address *addr = entry->data;
|
|
|
|
size_t orig_netmask = addr->netmask;
|
|
|
|
|
|
|
|
if (!addr->netmask)
|
|
|
|
{
|
|
|
|
/* if fallback netmask is not set, default to 255.255.255.0 */
|
|
|
|
addr->netmask = 24;
|
|
|
|
|
|
|
|
struct lif_dict_entry *entry = lif_dict_find(&iface->vars, "netmask");
|
|
|
|
if (entry != NULL)
|
|
|
|
addr->netmask = count_set_bits(entry->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
char addr_buf[512];
|
|
|
|
|
|
|
|
if (!lif_address_unparse(addr, addr_buf, sizeof addr_buf, true))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
addr->netmask = orig_netmask;
|
|
|
|
|
|
|
|
printf("%s\n", addr_buf);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
printf("%s\n", (const char *) entry->data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-19 01:26:20 +00:00
|
|
|
void
|
|
|
|
list_interfaces(struct lif_dict *collection, struct match_options *opts)
|
|
|
|
{
|
|
|
|
struct lif_node *iter;
|
|
|
|
|
2020-07-24 10:25:06 +00:00
|
|
|
if (opts->dot)
|
|
|
|
{
|
|
|
|
printf("digraph interfaces {\n");
|
|
|
|
printf("edge [color=blue fontname=Sans fontsize=10]\n");
|
|
|
|
printf("node [fontname=Sans fontsize=10]\n");
|
|
|
|
}
|
|
|
|
|
2020-07-19 01:26:20 +00:00
|
|
|
LIF_DICT_FOREACH(iter, collection)
|
|
|
|
{
|
|
|
|
struct lif_dict_entry *entry = iter->data;
|
|
|
|
struct lif_interface *iface = entry->data;
|
|
|
|
|
|
|
|
if (opts->is_auto && !iface->is_auto)
|
|
|
|
continue;
|
|
|
|
|
2020-07-19 01:31:44 +00:00
|
|
|
if (opts->exclude_pattern != NULL &&
|
|
|
|
!fnmatch(opts->exclude_pattern, iface->ifname, 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (opts->include_pattern != NULL &&
|
|
|
|
fnmatch(opts->include_pattern, iface->ifname, 0))
|
|
|
|
continue;
|
|
|
|
|
2020-07-19 01:34:38 +00:00
|
|
|
if (opts->pretty_print)
|
|
|
|
print_interface(iface);
|
2020-07-24 10:25:06 +00:00
|
|
|
else if (opts->dot)
|
|
|
|
print_interface_dot(collection, iface, NULL);
|
2020-07-19 01:34:38 +00:00
|
|
|
else
|
|
|
|
printf("%s\n", iface->ifname);
|
2020-07-19 01:26:20 +00:00
|
|
|
}
|
2020-07-24 10:25:06 +00:00
|
|
|
|
|
|
|
if (opts->dot)
|
|
|
|
printf("}\n");
|
2020-07-19 01:26:20 +00:00
|
|
|
}
|
|
|
|
|
2020-07-20 14:19:23 +00:00
|
|
|
void
|
|
|
|
list_state(struct lif_dict *state, struct match_options *opts)
|
|
|
|
{
|
|
|
|
struct lif_node *iter;
|
|
|
|
|
|
|
|
LIF_DICT_FOREACH(iter, state)
|
|
|
|
{
|
|
|
|
struct lif_dict_entry *entry = iter->data;
|
|
|
|
|
|
|
|
if (opts->exclude_pattern != NULL &&
|
|
|
|
!fnmatch(opts->exclude_pattern, entry->key, 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (opts->include_pattern != NULL &&
|
|
|
|
fnmatch(opts->include_pattern, entry->key, 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
printf("%s=%s\n", entry->key, (const char *) entry->data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-12 05:03:55 +00:00
|
|
|
static bool listing = false, listing_stat = false;
|
|
|
|
|
|
|
|
static void
|
|
|
|
handle_local(int short_opt, const struct if_option *opt, const char *opt_arg, const struct if_applet *applet)
|
|
|
|
{
|
|
|
|
(void) opt;
|
|
|
|
(void) applet;
|
|
|
|
|
|
|
|
switch (short_opt) {
|
|
|
|
case 'L':
|
|
|
|
listing = true;
|
|
|
|
break;
|
|
|
|
case 'P':
|
|
|
|
match_opts.pretty_print = true;
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
listing_stat = true;
|
|
|
|
break;
|
|
|
|
case 'D':
|
|
|
|
match_opts.dot = true;
|
|
|
|
break;
|
|
|
|
case 'p':
|
|
|
|
match_opts.property = opt_arg;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct if_option local_options[] = {
|
|
|
|
{'s', "state", NULL, "show configured state", false, handle_local},
|
|
|
|
{'p', "property", "property PROPERTY", "print values of properties matching PROPERTY", true, handle_local},
|
|
|
|
{'D', "dot", NULL, "generate a dependency graph", false, handle_local},
|
|
|
|
{'L', "list", NULL, "list matching interfaces", false, handle_local},
|
|
|
|
{'P', "pretty-print", NULL, "pretty print the interfaces instead of just listing", false, handle_local},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct if_option_group local_option_group = {
|
|
|
|
.desc = "Program-specific options",
|
|
|
|
.group_size = ARRAY_SIZE(local_options),
|
|
|
|
.group = local_options
|
|
|
|
};
|
|
|
|
|
2020-07-18 10:49:22 +00:00
|
|
|
int
|
2020-07-24 09:07:19 +00:00
|
|
|
ifquery_main(int argc, char *argv[])
|
2020-07-18 10:49:22 +00:00
|
|
|
{
|
2020-07-20 14:19:23 +00:00
|
|
|
struct lif_dict state = {};
|
|
|
|
struct lif_dict collection = {};
|
2020-07-18 10:49:22 +00:00
|
|
|
|
2020-08-12 04:51:53 +00:00
|
|
|
if (!lif_state_read_path(&state, exec_opts.state_file))
|
2020-07-20 14:19:23 +00:00
|
|
|
{
|
2020-08-12 04:51:53 +00:00
|
|
|
fprintf(stderr, "%s: could not parse %s\n", argv0, exec_opts.state_file);
|
2020-07-20 14:19:23 +00:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
2020-07-28 19:46:25 +00:00
|
|
|
if (!lif_interface_file_parse(&collection, exec_opts.interfaces_file))
|
2020-07-19 00:02:25 +00:00
|
|
|
{
|
2020-07-28 19:46:25 +00:00
|
|
|
fprintf(stderr, "%s: could not parse %s\n", argv0, exec_opts.interfaces_file);
|
2020-07-19 00:02:25 +00:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
2020-07-18 10:49:22 +00:00
|
|
|
|
2020-07-20 14:19:23 +00:00
|
|
|
/* --list --state is not allowed */
|
|
|
|
if (listing && listing_stat)
|
2020-08-12 05:10:35 +00:00
|
|
|
generic_usage(self_applet, EXIT_FAILURE);
|
2020-07-20 14:19:23 +00:00
|
|
|
|
2020-07-19 01:26:20 +00:00
|
|
|
if (listing)
|
|
|
|
{
|
|
|
|
list_interfaces(&collection, &match_opts);
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
}
|
2020-07-20 14:19:23 +00:00
|
|
|
else if (listing_stat)
|
|
|
|
{
|
|
|
|
list_state(&state, &match_opts);
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
}
|
2020-07-19 01:26:20 +00:00
|
|
|
|
2020-07-18 23:44:58 +00:00
|
|
|
if (optind >= argc)
|
2020-08-12 05:10:35 +00:00
|
|
|
generic_usage(self_applet, EXIT_FAILURE);
|
2020-07-18 23:44:58 +00:00
|
|
|
|
|
|
|
int idx = optind;
|
|
|
|
for (; idx < argc; idx++)
|
|
|
|
{
|
2020-07-20 14:19:23 +00:00
|
|
|
struct lif_interface *iface = lif_state_lookup(&state, &collection, argv[idx]);
|
2020-07-20 14:24:31 +00:00
|
|
|
|
|
|
|
if (iface == NULL)
|
|
|
|
{
|
|
|
|
struct lif_dict_entry *entry = lif_dict_find(&collection, argv[idx]);
|
|
|
|
|
|
|
|
if (entry != NULL)
|
|
|
|
iface = entry->data;
|
|
|
|
}
|
|
|
|
|
2020-07-20 14:19:23 +00:00
|
|
|
if (iface == NULL)
|
2020-07-18 23:44:58 +00:00
|
|
|
{
|
2020-07-24 10:52:15 +00:00
|
|
|
fprintf(stderr, "%s: unknown interface %s\n", argv0, argv[idx]);
|
2020-07-18 23:44:58 +00:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
2020-07-26 08:28:29 +00:00
|
|
|
if (match_opts.property != NULL)
|
|
|
|
print_interface_property(iface, match_opts.property);
|
|
|
|
else
|
|
|
|
print_interface(iface);
|
2020-07-18 23:44:58 +00:00
|
|
|
}
|
2020-07-18 10:49:22 +00:00
|
|
|
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
}
|
2020-07-24 09:07:19 +00:00
|
|
|
|
|
|
|
struct if_applet ifquery_applet = {
|
|
|
|
.name = "ifquery",
|
2020-08-12 04:37:36 +00:00
|
|
|
.desc = "query interface configuration",
|
2020-07-24 09:07:19 +00:00
|
|
|
.main = ifquery_main,
|
2020-08-12 05:10:35 +00:00
|
|
|
.usage = "ifquery [options] <interfaces>\n ifquery [options] --list",
|
2020-08-12 05:03:55 +00:00
|
|
|
.groups = { &global_option_group, &match_option_group, &exec_option_group, &local_option_group },
|
2020-07-24 09:07:19 +00:00
|
|
|
};
|