593 lines
16 KiB
C
593 lines
16 KiB
C
/*
|
|
* Copyright (c) 2016, 2017, 2018 Jonas 'Sortie' Termansen.
|
|
* Copyright (c) 2021 Juhani 'nortti' Krekelä.
|
|
*
|
|
* Permission to use, copy, modify, and 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.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* ifconfig.c
|
|
* Configure network interface.
|
|
*/
|
|
|
|
#include <sys/ioctl.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <arpa/inet.h>
|
|
#include <dirent.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <limits.h>
|
|
#include <net/if.h>
|
|
#include <netinet/if_ether.h>
|
|
#include <netinet/in.h>
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
struct if_all
|
|
{
|
|
struct if_info info;
|
|
struct if_status status;
|
|
struct if_config config;
|
|
};
|
|
|
|
static void link_id_print(const struct if_all* all, const void* ptr)
|
|
{
|
|
(void) all;
|
|
unsigned int id = *(const unsigned int*) ptr;
|
|
printf("%u", id);
|
|
}
|
|
|
|
static void link_type_print(const struct if_all* all, const void* ptr)
|
|
{
|
|
(void) all;
|
|
int type = *(const int*) ptr;
|
|
const char* type_string;
|
|
switch ( type )
|
|
{
|
|
case IF_TYPE_ETHERNET: type_string = "ether"; break;
|
|
case IF_TYPE_LOOPBACK: type_string = "loopback"; break;
|
|
default: type_string = "unknown"; break;
|
|
}
|
|
fputs(type_string, stdout);
|
|
}
|
|
|
|
static void link_up_print(const struct if_all* all, const void* ptr)
|
|
{
|
|
(void) all;
|
|
int flags = *(const int*) ptr;
|
|
fputs(flags & IF_STATUS_FLAGS_UP ? "yes" : "no", stdout);
|
|
}
|
|
|
|
static void link_name_print(const struct if_all* all, const void* ptr)
|
|
{
|
|
(void) all;
|
|
const char* name = (const char*) ptr;
|
|
fputs(name, stdout);
|
|
}
|
|
|
|
static void ether_address_print(const struct if_all* all, const void* ptr)
|
|
{
|
|
(void) all;
|
|
struct ether_addr* addr = (struct ether_addr*) ptr;
|
|
printf("%02x:%02x:%02x:%02x:%02x:%02x",
|
|
addr->ether_addr_octet[0], addr->ether_addr_octet[1],
|
|
addr->ether_addr_octet[2], addr->ether_addr_octet[3],
|
|
addr->ether_addr_octet[4], addr->ether_addr_octet[5]);
|
|
}
|
|
|
|
static void ether_hwaddress_print(const struct if_all* all, const void* ptr)
|
|
{
|
|
struct ether_addr hwaddr;
|
|
memcpy(&hwaddr, ptr, sizeof(hwaddr));
|
|
ether_address_print(all, &hwaddr);
|
|
}
|
|
|
|
static bool mac_parse(struct ether_addr* addr, const char* string)
|
|
{
|
|
for ( size_t i = 0; i < 6; i++ )
|
|
{
|
|
int upper;
|
|
if ( '0' <= string[i*3 + 0] && string[i*3 + 0] <= '9' )
|
|
upper = string[i*3 + 0] - '0';
|
|
else if ( 'a' <= string[i*3 + 0] && string[i*3 + 0] <= 'f' )
|
|
upper = string[i*3 + 0] - 'a' + 10;
|
|
else if ( 'A' <= string[i*3 + 0] && string[i*3 + 0] <= 'F' )
|
|
upper = string[i*3 + 0] - 'A' + 10;
|
|
else
|
|
return false;
|
|
int lower;
|
|
if ( '0' <= string[i*3 + 1] && string[i*3 + 1] <= '9' )
|
|
lower = string[i*3 + 1] - '0';
|
|
else if ( 'a' <= string[i*3 + 1] && string[i*3 + 1] <= 'f' )
|
|
lower = string[i*3 + 1] - 'a' + 10;
|
|
else if ( 'A' <= string[i*3 + 1] && string[i*3 + 1] <= 'F' )
|
|
lower = string[i*3 + 1] - 'A' + 10;
|
|
else
|
|
return false;
|
|
if ( string[i*3 + 2] != (i + 1 != 6 ? ':' : '\0') )
|
|
return false;
|
|
addr->ether_addr_octet[i] = upper << 4 | lower;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool ether_address_parse(const struct if_all* all,
|
|
void* ptr,
|
|
const char* string)
|
|
{
|
|
struct ether_addr* addr = (struct ether_addr*) ptr;
|
|
if ( !strcmp(string, "default") )
|
|
{
|
|
memcpy(addr, all->info.addr, sizeof(*addr));
|
|
return true;
|
|
}
|
|
return mac_parse(addr, string);
|
|
}
|
|
|
|
static void inet_address_print(const struct if_all* all, const void* ptr)
|
|
{
|
|
(void) all;
|
|
char addr[INET_ADDRSTRLEN];
|
|
inet_ntop(AF_INET, ptr, addr, sizeof(addr));
|
|
fputs(addr, stdout);
|
|
}
|
|
|
|
static bool inet_address_parse(const struct if_all* all,
|
|
void* ptr,
|
|
const char* string)
|
|
{
|
|
(void) all;
|
|
return inet_pton(AF_INET, string, ptr) == 1;
|
|
}
|
|
|
|
#define ARRAY_LENGTH(array) (sizeof(array) / sizeof((array)[0]))
|
|
|
|
struct configuration
|
|
{
|
|
const char* name;
|
|
size_t offset;
|
|
void (*print)(const struct if_all*, const void*);
|
|
bool (*parse)(const struct if_all*, void*, const char*);
|
|
bool hidden;
|
|
};
|
|
|
|
#define INFOOFFSET(parameter) \
|
|
(offsetof(struct if_all, info) + \
|
|
offsetof(struct if_info, parameter))
|
|
|
|
#define STATUSOFFSET(parameter) \
|
|
(offsetof(struct if_all, status) + \
|
|
offsetof(struct if_status, parameter))
|
|
|
|
#define CONFIGOFFSET(protocol, parameter) \
|
|
(offsetof(struct if_all, config) + \
|
|
offsetof(struct if_config, protocol) + \
|
|
offsetof(struct if_config_##protocol, parameter))
|
|
|
|
struct configuration link_configurations[] =
|
|
{
|
|
{ "up", STATUSOFFSET(flags), link_up_print, NULL, false },
|
|
{ "type", INFOOFFSET(type), link_type_print, NULL, false },
|
|
{ "id", INFOOFFSET(linkid), link_id_print, NULL, false },
|
|
{ "name", INFOOFFSET(name), link_name_print, NULL, true },
|
|
};
|
|
|
|
struct configuration ether_configurations[] =
|
|
{
|
|
{ "address", CONFIGOFFSET(ether, address),
|
|
ether_address_print, ether_address_parse, false },
|
|
{ "hwaddress", INFOOFFSET(addr), ether_hwaddress_print, NULL, false },
|
|
};
|
|
|
|
struct configuration loopback_configurations[] =
|
|
{
|
|
};
|
|
|
|
struct configuration inet_configurations[] =
|
|
{
|
|
{ "address", CONFIGOFFSET(inet, address),
|
|
inet_address_print, inet_address_parse, false },
|
|
{ "router", CONFIGOFFSET(inet, router),
|
|
inet_address_print, inet_address_parse, false },
|
|
{ "subnet", CONFIGOFFSET(inet, subnet),
|
|
inet_address_print, inet_address_parse, false },
|
|
};
|
|
|
|
struct protocol
|
|
{
|
|
const char* name;
|
|
int link_type_value;
|
|
struct configuration* configurations;
|
|
size_t configurations_count;
|
|
};
|
|
|
|
struct protocol protocols[] =
|
|
{
|
|
{ "link", 0,
|
|
link_configurations, ARRAY_LENGTH(link_configurations) },
|
|
{ "ether", IF_TYPE_ETHERNET,
|
|
ether_configurations, ARRAY_LENGTH(ether_configurations) },
|
|
{ "loopback", IF_TYPE_LOOPBACK,
|
|
loopback_configurations, ARRAY_LENGTH(loopback_configurations) },
|
|
{ "inet", 0,
|
|
inet_configurations, ARRAY_LENGTH(inet_configurations) },
|
|
};
|
|
|
|
static int filter_dev_netif(const struct dirent* entry)
|
|
{
|
|
char* path;
|
|
if ( asprintf(&path, "/dev/%s", entry->d_name) < 0 )
|
|
err(1, "malloc");
|
|
// TODO: Open with O_STAT or some future extension that lets us properly
|
|
// test whether this is a network interface before complaining we
|
|
// couldn't open it. Otherwise it's annoying for non-root users to get
|
|
// warnings about non-network-interfaces in /dev they aren't supposed
|
|
// to be able to open.
|
|
int fd = open(path, O_RDONLY | O_NOFOLLOW);
|
|
if ( fd < 0 )
|
|
{
|
|
struct stat st;
|
|
if ( lstat(path, &st) < 0 )
|
|
{
|
|
warn("stat: %s", path);
|
|
free(path);
|
|
return 0;
|
|
}
|
|
// TODO: Determine whether this is a network interface without having
|
|
// access to the device. Otherwise non-root users will be warned
|
|
// about non-network interfaces in /dev they're not supposed to be
|
|
// able to access.
|
|
if ( S_ISCHR(st.st_mode) )
|
|
warn("%s", path);
|
|
free(path);
|
|
return 0;
|
|
}
|
|
free(path);
|
|
int type = ioctl(fd, IOCGETTYPE);
|
|
close(fd);
|
|
return IOC_TYPE(type) == IOC_TYPE_NETWORK_INTERFACE;
|
|
}
|
|
|
|
enum specifier_type { ETHER, ETHERHW, INET, ID };
|
|
|
|
struct if_specifier
|
|
{
|
|
enum specifier_type type;
|
|
union
|
|
{
|
|
struct ether_addr mac_addr;
|
|
struct in_addr ipv4_addr;
|
|
unsigned int id;
|
|
};
|
|
};
|
|
|
|
static bool parse_specifier(struct if_specifier* specifier, const char* string)
|
|
{
|
|
if ( !strncmp(string, "ether:", strlen("ether:")) )
|
|
{
|
|
specifier->type = ETHER;
|
|
return mac_parse(&specifier->mac_addr, string + strlen("ether:"));
|
|
}
|
|
else if ( !strncmp(string, "etherhw:", strlen("etherhw:")) )
|
|
{
|
|
specifier->type = ETHERHW;
|
|
return mac_parse(&specifier->mac_addr, string + strlen("etherhw:"));
|
|
}
|
|
else if ( !strncmp(string, "inet:", strlen("inet:")) )
|
|
{
|
|
specifier->type = INET;
|
|
return inet_pton(AF_INET, string + strlen("inet:"),
|
|
&specifier->ipv4_addr) == 1;
|
|
}
|
|
else if ( !strncmp(string, "id:", strlen("id:")) )
|
|
{
|
|
specifier->type = ID;
|
|
const char* idstr = string + strlen("id:");
|
|
char* end;
|
|
errno = 0;
|
|
unsigned long ulong = strtoul(idstr, &end, 10);
|
|
if ( errno || !*idstr || *end || ulong > UINT_MAX )
|
|
return false;
|
|
specifier->id = ulong;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static int find_interface(const char* specifier_string,
|
|
char if_name[IF_NAMESIZE])
|
|
{
|
|
struct if_specifier specifier;
|
|
if ( !parse_specifier(&specifier, specifier_string) )
|
|
errx(1, "Invalid interface specifier: %s", specifier_string);
|
|
|
|
struct if_nameindex* ifs = if_nameindex();
|
|
if ( !ifs )
|
|
err(1, "if_nameindex");
|
|
|
|
int if_fd = -1;
|
|
for ( size_t i = 0; ifs[i].if_index || ifs[i].if_name; i++ )
|
|
{
|
|
const char* name = ifs[i].if_name;
|
|
|
|
char* path;
|
|
if ( asprintf(&path, "/dev/%s", name) < 0 )
|
|
err(1, "malloc");
|
|
int fd = open(path, O_RDONLY);
|
|
if ( fd < 0 )
|
|
err(1, "%s", path);
|
|
free(path);
|
|
|
|
struct if_info ifinfo;
|
|
struct if_config ifconfig;
|
|
if ( ioctl(fd, NIOC_GETINFO, &ifinfo) < 0 )
|
|
err(1, "%s: ioctl: NIOC_GETINFO", name);
|
|
if ( ioctl(fd, NIOC_GETCONFIG, &ifconfig) < 0 )
|
|
err(1, "%s: ioctl: NIOC_GETCONFIG", name);
|
|
|
|
bool match = false;
|
|
switch ( specifier.type )
|
|
{
|
|
case ETHER:
|
|
match = ifinfo.type == IF_TYPE_ETHERNET &&
|
|
!memcmp(&specifier.mac_addr, &ifconfig.ether.address,
|
|
sizeof(struct ether_addr));
|
|
break;
|
|
case ETHERHW:
|
|
match = ifinfo.type == IF_TYPE_ETHERNET &&
|
|
!memcmp(&specifier.mac_addr, &ifinfo.addr,
|
|
sizeof(struct ether_addr));
|
|
break;
|
|
case INET:
|
|
match = !memcmp(&specifier.ipv4_addr, &ifconfig.inet.address,
|
|
sizeof(struct in_addr));
|
|
break;
|
|
case ID:
|
|
match = ifinfo.linkid == specifier.id;
|
|
break;
|
|
}
|
|
|
|
// Ensure the specifier unambiguously matches an interface.
|
|
if ( match && if_fd != -1 )
|
|
errx(1, "Ambiguous specifier; matches at least %s and %s: %s",
|
|
if_name, name, specifier_string);
|
|
|
|
if ( match )
|
|
{
|
|
if_fd = fd;
|
|
strlcpy(if_name, name, IF_NAMESIZE);
|
|
}
|
|
else
|
|
close(fd);
|
|
|
|
}
|
|
|
|
if_freenameindex(ifs);
|
|
|
|
if ( if_fd == -1 )
|
|
errx(1, "Specifier does not match any interfaces: %s",
|
|
specifier_string);
|
|
|
|
return if_fd;
|
|
}
|
|
|
|
static void compact_arguments(int* argc, char*** argv)
|
|
{
|
|
for ( int i = 0; i < *argc; i++ )
|
|
{
|
|
while ( i < *argc && !(*argv)[i] )
|
|
{
|
|
for ( int n = i; n < *argc; n++ )
|
|
(*argv)[n] = (*argv)[n+1];
|
|
(*argc)--;
|
|
}
|
|
}
|
|
}
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
bool list = false;
|
|
|
|
for ( int i = 1; i < argc; i++ )
|
|
{
|
|
const char* arg = argv[i];
|
|
if ( arg[0] != '-' || !arg[1] )
|
|
continue;
|
|
argv[i] = NULL;
|
|
if ( !strcmp(arg, "--") )
|
|
break;
|
|
if ( arg[1] != '-' )
|
|
{
|
|
char c;
|
|
while ( (c = *++arg) ) switch ( c )
|
|
{
|
|
case 'l': list = true; break;
|
|
default:
|
|
errx(1, "unknown option -- '%c'", c);
|
|
}
|
|
}
|
|
else
|
|
errx(1, "unknown option: %s", arg);
|
|
}
|
|
|
|
compact_arguments(&argc, &argv);
|
|
|
|
int devices_count = 1;
|
|
struct dirent** devices = NULL;
|
|
if ( argc <= 1 )
|
|
{
|
|
devices_count = scandir("/dev", &devices, filter_dev_netif, alphasort);
|
|
if ( devices_count < 0 )
|
|
err(1, "scandir: /dev");
|
|
}
|
|
|
|
int result = 0;
|
|
for ( int d = 0; d < devices_count; d++ )
|
|
{
|
|
char if_name[IF_NAMESIZE];
|
|
const char* name = devices ? devices[d]->d_name : argv[1];
|
|
int fd;
|
|
if ( strchr(name, '/') )
|
|
fd = open(name, O_RDONLY);
|
|
else if ( strchr(name, ':') )
|
|
{
|
|
fd = find_interface(name, if_name);
|
|
name = if_name;
|
|
}
|
|
else
|
|
{
|
|
char* path;
|
|
if ( asprintf(&path, "/dev/%s", name) < 0 )
|
|
err(1, "malloc");
|
|
fd = open(path, O_RDONLY);
|
|
free(path);
|
|
}
|
|
if ( fd < 0 )
|
|
err(1, "%s", name);
|
|
struct if_all all;
|
|
if ( ioctl(fd, NIOC_GETINFO, &all.info) < 0 )
|
|
err(1, "%s: ioctl: NIOC_GETINFO", name);
|
|
if ( ioctl(fd, NIOC_GETSTATUS, &all.status) < 0 )
|
|
err(1, "%s: ioctl: NIOC_GETSTATUS", name);
|
|
if ( ioctl(fd, NIOC_GETCONFIG, &all.config) < 0 )
|
|
err(1, "%s: ioctl: NIOC_GETCONFIG", name);
|
|
if ( list && argc == 1 )
|
|
{
|
|
puts(name);
|
|
continue;
|
|
}
|
|
else if ( list && (argc == 2 || argc == 3) )
|
|
{
|
|
bool found = false;
|
|
for ( size_t i = 0; i < ARRAY_LENGTH(protocols); i++ )
|
|
{
|
|
struct protocol* protocol = &protocols[i];
|
|
if ( 3 <= argc && strcmp(protocol->name, argv[2]) != 0 )
|
|
continue;
|
|
if ( protocol->link_type_value &&
|
|
all.info.type != protocol->link_type_value )
|
|
{
|
|
if ( 3 <= argc )
|
|
errx(1, "%s: %s: Interface does not support protocol",
|
|
name, argv[2]);
|
|
continue;
|
|
}
|
|
if ( argc < 3 )
|
|
{
|
|
puts(protocol->name);
|
|
continue;
|
|
}
|
|
found = true;
|
|
for ( size_t j = 0; j < protocol->configurations_count; j++ )
|
|
puts(protocol->configurations[j].name);
|
|
}
|
|
if ( 3 <= argc && !found )
|
|
errx(1, "%s: %s: No such protocol", name, argv[2]);
|
|
continue;
|
|
}
|
|
else if ( argc <= 2 )
|
|
{
|
|
printf("%s:\n", name);
|
|
for ( size_t i = 0; i < ARRAY_LENGTH(protocols); i++ )
|
|
{
|
|
struct protocol* protocol = &protocols[i];
|
|
if ( protocol->link_type_value &&
|
|
all.info.type != protocol->link_type_value )
|
|
continue;
|
|
putchar('\t');
|
|
fputs(protocol->name, stdout);
|
|
for ( size_t j = 0; j < protocol->configurations_count; j++ )
|
|
{
|
|
struct configuration* configuration =
|
|
&protocol->configurations[j];
|
|
if ( configuration->hidden )
|
|
continue;
|
|
putchar(' ');
|
|
fputs(configuration->name, stdout);
|
|
putchar(' ');
|
|
void* ptr = ((char*) &all + configuration->offset);
|
|
configuration->print(&all, ptr);
|
|
}
|
|
putchar('\n');
|
|
}
|
|
continue;
|
|
}
|
|
struct protocol* protocol = NULL;
|
|
for ( int i = 2; i < argc; )
|
|
{
|
|
const char* operand = argv[i++];
|
|
bool found = false;
|
|
for ( size_t n = 0;
|
|
protocol && n < protocol->configurations_count;
|
|
n++ )
|
|
{
|
|
struct configuration* configuration =
|
|
&protocol->configurations[n];
|
|
if ( strcmp(operand, configuration->name) != 0 )
|
|
continue;
|
|
found = true;
|
|
void* ptr = ((char*) &all + configuration->offset);
|
|
if ( list )
|
|
{
|
|
configuration->print(&all, ptr);
|
|
putchar('\n');
|
|
}
|
|
else
|
|
{
|
|
if ( !configuration->parse )
|
|
errx(1, "%s: %s: %s: Configuration is read-only",
|
|
name, protocol->name, operand);
|
|
if ( i == argc )
|
|
errx(1, "%s: %s: %s: Expected parameter",
|
|
name, protocol->name, operand);
|
|
const char* parameter = argv[i++];
|
|
if ( !configuration->parse(&all, ptr, parameter) )
|
|
errx(1, "%s: %s: %s: Invalid value: %s",
|
|
name, protocol->name, operand, parameter);
|
|
}
|
|
}
|
|
for ( size_t n = 0; !found && n < ARRAY_LENGTH(protocols); n++ )
|
|
{
|
|
struct protocol* new_protocol = &protocols[n];
|
|
if ( strcmp(operand, new_protocol->name) != 0 )
|
|
continue;
|
|
if ( new_protocol->link_type_value &&
|
|
all.info.type != new_protocol->link_type_value )
|
|
errx(1, "%s: %s: Interface does not support protocol",
|
|
name, operand);
|
|
found = true;
|
|
protocol = new_protocol;
|
|
}
|
|
if ( !found )
|
|
{
|
|
if ( !protocol )
|
|
errx(1, "%s: %s: No such protocol", name, operand);
|
|
errx(1, "%s: %s: No such protocol or configuration of protocol "
|
|
"%s", name, operand, protocol->name);
|
|
}
|
|
}
|
|
if ( !list && ioctl(fd, NIOC_SETCONFIG, &all.config) < 0 )
|
|
err(1, "%s: ioctl: NIOC_SETCONFIG", name);
|
|
close(fd);
|
|
}
|
|
|
|
if ( ferror(stdout) || fflush(stdout) == EOF )
|
|
err(1, "stdout");
|
|
return result;
|
|
}
|