ladybird/Userland/Utilities/route.cpp
Shannon Booth e2e7c4d574 Everywhere: Use to_number<T> instead of to_{int,uint,float,double}
In a bunch of cases, this actually ends up simplifying the code as
to_number will handle something such as:

```
Optional<I> opt;
if constexpr (IsSigned<I>)
    opt = view.to_int<I>();
else
    opt = view.to_uint<I>();
```

For us.

The main goal here however is to have a single generic number conversion
API between all of the String classes.
2023-12-23 20:41:07 +01:00

221 lines
7.9 KiB
C++

/*
* Copyright (c) 2022, Brandon Pruitt <brapru@pm.me>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/ByteString.h>
#include <AK/IPv4Address.h>
#include <AK/JsonArray.h>
#include <AK/JsonObject.h>
#include <AK/QuickSort.h>
#include <AK/StringView.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/File.h>
#include <LibCore/ProcessStatisticsReader.h>
#include <LibCore/System.h>
#include <LibMain/Main.h>
#include <net/if.h>
#include <net/route.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <unistd.h>
ErrorOr<int> serenity_main(Main::Arguments arguments)
{
TRY(Core::System::pledge("stdio rpath inet"));
TRY(Core::System::unveil("/sys/kernel/net", "r"));
TRY(Core::System::unveil(nullptr, nullptr));
StringView modify_action;
StringView value_host_address;
StringView value_network_address;
StringView value_gateway_address;
StringView value_netmask_address;
StringView value_interface;
Core::ArgsParser args_parser;
args_parser.set_general_help("Display kernel routing table");
args_parser.add_positional_argument(modify_action, "Modify the global routing table { add | del }", "action", Core::ArgsParser::Required::No);
args_parser.add_option(value_host_address, "Target destination is an IPv4 address", "host", 'h', "host");
args_parser.add_option(value_network_address, "Target destination is a network address", "net", 'n', "net");
args_parser.add_option(value_gateway_address, "Route packets via a gateway", "gw", 'g', "gw");
args_parser.add_option(value_netmask_address, "The netmask to be used when adding a network route", "netmask", 'm', "netmask");
args_parser.add_option(value_interface, "Force the route to be associated with the specified device interface", "interface", 'i', "interface");
args_parser.parse(arguments);
enum class Alignment {
Left,
Right
};
struct Column {
ByteString title;
Alignment alignment { Alignment::Left };
int width { 0 };
ByteString buffer;
};
Vector<Column> columns;
int destination_column = -1;
int gateway_column = -1;
int genmask_column = -1;
int flags_column = -1;
int interface_column = -1;
auto add_column = [&](auto title, auto alignment, auto width) {
columns.append({ title, alignment, width, {} });
return columns.size() - 1;
};
destination_column = add_column("Destination", Alignment::Left, 15);
gateway_column = add_column("Gateway", Alignment::Left, 15);
genmask_column = add_column("Genmask", Alignment::Left, 15);
flags_column = add_column("Flags", Alignment::Left, 5);
interface_column = add_column("Interface", Alignment::Left, 9);
auto print_column = [](auto& column, auto& string) {
if (!column.width) {
out("{}", string);
return;
}
if (column.alignment == Alignment::Right) {
out("{:>{1}} "sv, string, column.width);
} else {
out("{:<{1}} "sv, string, column.width);
}
};
if (modify_action.is_empty()) {
auto file = TRY(Core::File::open("/sys/kernel/net/route"sv, Core::File::OpenMode::Read));
auto file_contents = TRY(file->read_until_eof());
auto json = TRY(JsonValue::from_string(file_contents));
outln("Kernel IP routing table");
for (auto& column : columns)
print_column(column, column.title);
outln();
Vector<JsonValue> sorted_regions = json.as_array().values();
quick_sort(sorted_regions, [](auto& a, auto& b) {
return a.as_object().get_byte_string("destination"sv).value_or({}) < b.as_object().get_byte_string("destination"sv).value_or({});
});
for (auto& value : sorted_regions) {
auto& if_object = value.as_object();
auto destination = if_object.get_byte_string("destination"sv).value_or({});
auto gateway = if_object.get_byte_string("gateway"sv).value_or({});
auto genmask = if_object.get_byte_string("genmask"sv).value_or({});
auto interface = if_object.get_byte_string("interface"sv).value_or({});
auto flags = if_object.get_u32("flags"sv).value_or(0);
StringBuilder flags_builder;
if (flags & RTF_UP)
flags_builder.append('U');
if (flags & RTF_GATEWAY)
flags_builder.append('G');
if (flags & RTF_HOST)
flags_builder.append('H');
if (destination_column != -1)
columns[destination_column].buffer = destination;
if (gateway_column != -1)
columns[gateway_column].buffer = gateway;
if (genmask_column != -1)
columns[genmask_column].buffer = genmask;
if (flags_column != -1)
columns[flags_column].buffer = flags_builder.string_view();
if (interface_column != -1)
columns[interface_column].buffer = interface;
for (auto& column : columns)
print_column(column, column.buffer);
outln();
};
}
if (!modify_action.is_empty()) {
bool const action_add = (modify_action == "add");
bool const action_del = (modify_action == "del");
if (!action_add && !action_del) {
warnln("Invalid modify action: {}", modify_action);
return 1;
}
if (value_host_address.is_empty() && value_network_address.is_empty()) {
warnln("No target host or network specified");
return 1;
}
Optional<IPv4Address> destination;
if (!value_host_address.is_empty())
destination = AK::IPv4Address::from_string(value_host_address);
StringView address;
StringView cidr;
if (!value_network_address.is_empty()) {
// Check if a CIDR notation was provided and parse accordingly
if (auto position = value_network_address.find('/'); position.has_value()) {
address = value_network_address.substring_view(0, position.value());
cidr = value_network_address.substring_view(position.value() + 1);
} else {
address = value_network_address;
}
destination = AK::IPv4Address::from_string(address);
}
if (!destination.has_value()) {
warnln("Invalid destination IPv4 address");
return 1;
}
auto gateway = AK::IPv4Address::from_string(value_gateway_address);
if (action_add && !gateway.has_value()) {
warnln("Invalid gateway IPv4 address: '{}'", value_gateway_address);
return 1;
}
Optional<IPv4Address> genmask;
if (auto cidr_int = cidr.to_number<int>(); cidr_int.has_value())
genmask = AK::IPv4Address::netmask_from_cidr(cidr_int.value());
else
genmask = AK::IPv4Address::from_string(value_netmask_address);
if (!genmask.has_value()) {
warnln("Invalid genmask IPv4 address: '{}'", value_netmask_address);
return 1;
}
int fd = TRY(Core::System::socket(AF_INET, SOCK_DGRAM, IPPROTO_IP));
rtentry rt {};
memset(&rt, 0, sizeof(rt));
rt.rt_dev = const_cast<char*>(value_interface.characters_without_null_termination());
rt.rt_gateway.sa_family = AF_INET;
((sockaddr_in&)rt.rt_dst).sin_addr.s_addr = destination.value().to_in_addr_t();
((sockaddr_in&)rt.rt_gateway).sin_addr.s_addr = gateway.value_or(IPv4Address {}).to_in_addr_t();
((sockaddr_in&)rt.rt_genmask).sin_addr.s_addr = genmask.value().to_in_addr_t();
rt.rt_flags = RTF_UP;
if (!value_host_address.is_empty())
rt.rt_flags |= RTF_HOST;
rt.rt_flags |= RTF_GATEWAY;
if (action_add)
TRY(Core::System::ioctl(fd, SIOCADDRT, &rt));
if (action_del)
TRY(Core::System::ioctl(fd, SIOCDELRT, &rt));
}
return 0;
}