#include <arpa/inet.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <NetworkAddress.h>
extern const char* __progname;
const char* kProgramName = __progname;
enum modes {
RTM_LIST = 0,
RTM_DELETE,
RTM_ADD,
RTM_GET,
RTM_CHANGE,
RTM_FLUSH,
};
enum preferredPrefixFormat {
PREFIX_PREFER_NETMASK = 0,
PREFIX_PREFER_CIDR,
};
struct address_family {
int family;
const char* name;
const char* identifiers[4];
int maxAddressLength;
int preferredPrefixFormat;
};
static const address_family kFamilies[] = {
{
AF_INET,
"IPv4",
{"AF_INET", "inet", "ipv4", NULL},
15,
PREFIX_PREFER_NETMASK,
},
{
AF_INET6,
"IPv6",
{"AF_INET6", "inet6", "ipv6", NULL},
39,
PREFIX_PREFER_CIDR,
},
{ -1, NULL, {NULL}, -1, -1 }
};
void
usage(int status)
{
printf("usage: %s [command] [<interface>] [<address family>] "
"<address|default> [<option/flags>...]\n"
"Where <command> can be the one of:\n"
" add - add a route for the specified interface\n"
" delete - deletes the specified route\n"
" list - list with filters [default]\n"
"<option> can be the following:\n"
" netmask <addr> - networking subnet mask\n"
" prefixlen <number> - subnet mask length in bits\n"
" gw <addr> - gateway address\n"
" mtu <bytes> - maximal transfer unit\n"
"And <flags> can be: reject, local, host\n\n"
"Example:\n"
"\t%s add /dev/net/ipro1000/0 default gw 192.168.0.254\n",
kProgramName, kProgramName);
exit(status);
}
bool
prepare_request(struct ifreq& request, const char* name)
{
if (strlen(name) >= IF_NAMESIZE) {
fprintf(stderr, "%s: interface name \"%s\" is too long.\n",
kProgramName, name);
return false;
}
strcpy(request.ifr_name, name);
return true;
}
bool
get_address_family(const char* argument, int32& familyIndex)
{
for (int32 i = 0; kFamilies[i].family >= 0; i++) {
for (int32 j = 0; kFamilies[i].identifiers[j]; j++) {
if (!strcmp(argument, kFamilies[i].identifiers[j])) {
familyIndex = i;
return true;
}
}
}
familyIndex = 0;
return false;
}
bool
parse_address(int32 familyIndex, const char* argument, BNetworkAddress& address)
{
if (argument == NULL)
return false;
return address.SetTo(kFamilies[familyIndex].family, argument,
(uint16)0, B_NO_ADDRESS_RESOLUTION) == B_OK;
}
bool
prefix_length_to_mask(int32 familyIndex, const char* argument,
BNetworkAddress& mask)
{
if (argument == NULL)
return false;
char* end;
uint32 prefixLength = strtoul(argument, &end, 10);
if (end == argument)
return false;
return mask.SetToMask(kFamilies[familyIndex].family, prefixLength) == B_OK;
}
void
list_routes(int socket, const char *interfaceName, route_entry &route)
{
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
if (ioctl(socket, SIOCGRTSIZE, &config, sizeof(struct ifconf)) < 0)
return;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return;
void *buffer = malloc(size);
if (buffer == NULL) {
fprintf(stderr, "%s: Out of memory.\n", kProgramName);
return;
}
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(socket, SIOCGRTTABLE, &config, sizeof(struct ifconf)) < 0)
return;
ifreq *interface = (ifreq*)buffer;
ifreq *end = (ifreq*)((uint8*)buffer + size);
const address_family *family = NULL;
for (int32 i = 0; kFamilies[i].family >= 0; i++) {
if (interface->ifr_route.destination->sa_family
== kFamilies[i].family) {
family = &kFamilies[i];
break;
}
}
int addressLength = family->maxAddressLength;
printf("%s routing table:\n", family->name);
if (family->preferredPrefixFormat == PREFIX_PREFER_NETMASK) {
printf("%*s %*s %*s Flags Interface\n", addressLength, "Destination",
addressLength, "Netmask", addressLength, "Gateway");
} else {
printf("%*s %*s Flags Interface\n", addressLength, "Destination",
addressLength, "Gateway");
}
while (interface < end) {
route_entry& route = interface->ifr_route;
if (interfaceName == NULL
|| !strcmp(interfaceName, interface->ifr_name)) {
if (family != NULL) {
BNetworkAddress destination(*route.destination);
printf("%*s", addressLength, destination.ToString().String());
if (route.mask != NULL) {
BNetworkAddress mask;
mask.SetTo(*route.mask);
if (family->preferredPrefixFormat
== PREFIX_PREFER_NETMASK) {
printf(" %*s ", addressLength,
mask.ToString().String());
} else {
printf("/%-3zd ", mask.PrefixLength());
}
} else {
if (family->preferredPrefixFormat
== PREFIX_PREFER_NETMASK) {
printf(" %*s ", addressLength, "-");
} else
printf(" ");
}
if ((route.flags & RTF_GATEWAY) != 0) {
BNetworkAddress gateway;
if (route.gateway != NULL)
gateway.SetTo(*route.gateway);
printf("%*s ", addressLength, gateway.ToString().String());
} else
printf("%*s ", family->maxAddressLength, "-");
} else
printf("unknown family ");
if (route.flags != 0) {
const struct {
int value;
const char *name;
} kFlags[] = {
{RTF_DEFAULT, "D"},
{RTF_REJECT, "R"},
{RTF_HOST, "H"},
{RTF_LOCAL, "L"},
{RTF_DYNAMIC, "D"},
{RTF_MODIFIED, "M"},
};
for (uint32 i = 0; i < sizeof(kFlags) / sizeof(kFlags[0]);
i++) {
if ((route.flags & kFlags[i].value) != 0) {
printf(kFlags[i].name);
} else
putchar('-');
}
printf(" ");
} else
printf("------ ");
printf("%s", interface->ifr_name);
putchar('\n');
}
int32 addressSize = 0;
if (route.destination != NULL)
addressSize += route.destination->sa_len;
if (route.mask != NULL)
addressSize += route.mask->sa_len;
if (route.gateway != NULL)
addressSize += route.gateway->sa_len;
interface = (ifreq*)((addr_t)interface + IF_NAMESIZE
+ sizeof(route_entry) + addressSize);
}
putchar('\n');
free(buffer);
}
void
delete_route(int socket, const char *interface, route_entry &route)
{
ifreq request;
if (!prepare_request(request, interface))
return;
request.ifr_route = route;
if (ioctl(socket, SIOCDELRT, &request, sizeof(request)) < 0) {
fprintf(stderr, "%s: Could not delete route for %s: %s\n",
kProgramName, interface, strerror(errno));
}
}
void
add_route(int socket, const char *interface, route_entry &route)
{
ifreq request;
if (!prepare_request(request, interface))
return;
route.flags |= RTF_STATIC;
request.ifr_route = route;
if (ioctl(socket, SIOCADDRT, &request, sizeof(request)) < 0) {
fprintf(stderr, "%s: Could not add route for %s: %s\n",
kProgramName, interface, strerror(errno));
}
}
void
get_route(int socket, route_entry &route)
{
union {
route_entry request;
uint8 buffer[512];
};
request = route;
if (ioctl(socket, SIOCGETRT, buffer, sizeof(buffer)) < 0) {
fprintf(stderr, "%s: Could not get route: %s\n",
kProgramName, strerror(errno));
return;
}
const address_family *family = NULL;
for (int32 i = 0; kFamilies[i].family >= 0; i++) {
if (route.destination->sa_family == kFamilies[i].family) {
family = &kFamilies[i];
break;
}
}
if (family != NULL) {
BNetworkAddress destination(*request.destination);
BNetworkAddress mask(*request.mask);
printf("%s", destination.ToString().String());
printf("/%zd ", mask.PrefixLength());
BNetworkAddress gateway(*request.gateway);
if (request.flags & RTF_GATEWAY)
printf("gateway %s ", gateway.ToString().String());
BNetworkAddress source(*request.source);
printf("source %s\n", source.ToString().String());
} else {
printf("unknown family ");
}
}
int
main(int argc, char** argv)
{
if (argc > 1 && (!strcmp(argv[1], "--help") || !strcmp(argv[1], "-h")))
usage(0);
int32 mode = RTM_LIST;
if (argc > 1) {
if (!strcmp(argv[1], "delete")
|| !strcmp(argv[1], "del")
|| !strcmp(argv[1], "-d")) {
if (argc < 3)
usage(1);
mode = RTM_DELETE;
} else if (!strcmp(argv[1], "add")
|| !strcmp(argv[1], "-a")) {
if (argc < 3)
usage(1);
mode = RTM_ADD;
} else if (!strcmp(argv[1], "get")) {
if (argc < 3)
usage(1);
mode = RTM_GET;
}
}
int32 i = 2;
int32 interfaceIndex = i;
bool familySpecified = false;
int32 familyIndex = 0;
const char *interface = NULL;
BNetworkAddress destination;
BNetworkAddress mask;
BNetworkAddress gateway;
bool defaultRoute = false;
route_entry route;
memset(&route, 0, sizeof(route_entry));
while (i < argc && i < 5) {
if (i <= 3 && familySpecified == false
&& get_address_family(argv[i], familyIndex)) {
familySpecified = true;
if (i == 2)
interfaceIndex = -1;
}
if (!strcmp(argv[i], "default")) {
defaultRoute = true;
route.flags = RTF_DEFAULT;
i++;
break;
} else if (parse_address(familyIndex, argv[i], destination)) {
if (destination.IsEmpty()) {
defaultRoute = true;
route.flags = RTF_DEFAULT;
}
i++;
break;
}
i++;
}
if (!defaultRoute && destination.IsEmpty() && mode != RTM_LIST)
usage(1);
if (i == 3)
interfaceIndex = -1;
if (interfaceIndex != -1 && interfaceIndex < argc)
interface = argv[interfaceIndex];
if (i < argc && parse_address(familyIndex, argv[i], mask))
i++;
while (i < argc) {
if (!strcmp(argv[i], "gw") || !strcmp(argv[i], "gateway")) {
if (!parse_address(familyIndex, argv[i + 1], gateway)) {
fprintf(stderr, "%s: Option 'gw' needs valid address "
"parameter\n", kProgramName);
exit(1);
}
i++;
} else if (!strcmp(argv[i], "nm") || !strcmp(argv[i], "netmask")) {
if (!mask.IsEmpty()) {
fprintf(stderr, "%s: Netmask or prefix length is specified "
"twice\n", kProgramName);
exit(1);
}
if (!parse_address(familyIndex, argv[i + 1], mask)) {
fprintf(stderr, "%s: Option 'netmask' needs valid address "
"parameter\n", kProgramName);
exit(1);
}
i++;
} else if (!strcmp(argv[i], "plen") || !strcmp(argv[i], "prefixlen")
|| !strcmp(argv[i], "prefix-length")) {
if (!mask.IsEmpty()) {
fprintf(stderr, "%s: Netmask or prefix length is specified "
"twice\n", kProgramName);
exit(1);
}
if (!prefix_length_to_mask(familyIndex, argv[i + 1], mask)) {
fprintf(stderr, "%s: Option 'prefixlen' is invalid for this "
"address family\n", kProgramName);
exit(1);
}
i++;
} else if (!strcmp(argv[i], "mtu")) {
route.mtu = argv[i + 1] ? strtol(argv[i + 1], NULL, 0) : 0;
if (route.mtu <= 500) {
fprintf(stderr, "%s: Option 'mtu' exptected valid max transfer "
"unit size\n", kProgramName);
exit(1);
}
i++;
} else if (!strcmp(argv[i], "host")) {
route.flags |= RTF_HOST;
} else if (!strcmp(argv[i], "local")) {
route.flags |= RTF_LOCAL;
} else if (!strcmp(argv[i], "reject")) {
route.flags |= RTF_REJECT;
} else
usage(1);
i++;
}
if (!destination.IsEmpty())
route.destination = (sockaddr*)destination;
if (!mask.IsEmpty())
route.mask = (sockaddr*)mask;
if (!gateway.IsEmpty()) {
route.gateway = (sockaddr*)gateway;
route.flags |= RTF_GATEWAY;
}
int socket = ::socket(kFamilies[familyIndex].family, SOCK_DGRAM, 0);
if (socket < 0) {
fprintf(stderr, "%s: The requested address family is not available.\n",
kProgramName);
return 1;
}
switch (mode) {
case RTM_ADD:
if (interface == NULL) {
fprintf(stderr, "%s: You need to specify an interface when "
"adding a route.\n", kProgramName);
usage(1);
}
add_route(socket, interface, route);
break;
case RTM_DELETE:
if (interface == NULL) {
fprintf(stderr, "%s: You need to specify an interface when "
"removing a route.\n", kProgramName);
usage(1);
}
delete_route(socket, interface, route);
break;
case RTM_LIST:
if (familySpecified)
list_routes(socket, interface, route);
else {
for (int32 i = 0; kFamilies[i].family >= 0; i++) {
int socket = ::socket(kFamilies[i].family, SOCK_DGRAM, 0);
if (socket < 0)
continue;
list_routes(socket, interface, route);
close(socket);
}
}
break;
case RTM_GET:
get_route(socket, route);
break;
}
close(socket);
return 0;
}
