ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-06-19 07:38:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

net: clean up header fields and accessors

Browse Source 
Apply the style rule that an accessor is named similar to the the underlying
value. Provide read and write accessors for each mandatory header attribute.
Fix some incorrect structure in the headers like with the flags field
in Ipv4_packet.

Ref #2490
This commit is contained in:
Martin Stein
2017-09-14 15:10:32 +02:00
committed by Christian Helmuth
parent 7b55d4d5d9
commit d0f5838c61
21 changed files with 299 additions and 443 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
repos/os/src/lib/net/ipv4.cc
View File

@ -26,11 +26,11 @@ void Net::Ipv4_packet::print(Genode::Output &output) const
{
Genode::print(output, "\033[32mIPV4\033[0m ", src(), " > ", dst(), " ");
switch (protocol()) {
case Tcp_packet::IP_ID:
case Protocol::TCP:
Genode::print(output,
*reinterpret_cast<Tcp_packet const *>(data<void>()));
break;
case Udp_packet::IP_ID:
case Protocol::UDP:
Genode::print(output,
*reinterpret_cast<Udp_packet const *>(data<void>()));
break;
@ -84,7 +84,7 @@ Ipv4_address Ipv4_packet::ip_from_string(const char *ip)
Genode::uint16_t Ipv4_packet::calculate_checksum(Ipv4_packet const &packet)
{
Genode::uint16_t const *data = packet.header<Genode::uint16_t>();
Genode::uint16_t const *data = (Genode::uint16_t *)&packet;
Genode::uint32_t const sum = host_to_big_endian(data[0])
+ host_to_big_endian(data[1])
+ host_to_big_endian(data[2])

2
repos/os/src/lib/net/stat.cc
View File

@ -30,7 +30,7 @@ enum Measurement::status Measurement::_check(Net::Ethernet_frame * eth,
Ipv4_packet *ip = new (eth->data<void>()) Ipv4_packet(size -
sizeof(Ethernet_frame));
if (ip->protocol() != Udp_packet::IP_ID)
if (ip->protocol() != Ipv4_packet::Protocol::UDP)
return Measurement::UNKNOWN;
Udp_packet *udp = new (ip->data<void>()) Udp_packet(size - sizeof(Ethernet_frame)

3
repos/os/src/lib/net/tcp.cc
View File

@ -27,5 +27,8 @@ void Net::Tcp_packet::print(Genode::Output &output) const
if (psh()) { Genode::print(output, "p"); }
if (ack()) { Genode::print(output, "a"); }
if (urg()) { Genode::print(output, "u"); }
if (ece()) { Genode::print(output, "e"); }
if (crw()) { Genode::print(output, "c"); }
if (ns()) { Genode::print(output, "n"); }
Genode::print(output, "' ");
}

2
repos/os/src/server/nic_bridge/component.cc
View File

@ -54,7 +54,7 @@ bool Session_component::handle_ip(Ethernet_frame *eth, Genode::size_t size)
Ipv4_packet *ip =
new (eth->data<void>()) Ipv4_packet(size - sizeof(Ethernet_frame));
if (ip->protocol() == Udp_packet::IP_ID)
if (ip->protocol() == Ipv4_packet::Protocol::UDP)
{
Udp_packet *udp = new (ip->data<void>())
Udp_packet(size - sizeof(Ipv4_packet));

2
repos/os/src/server/nic_bridge/nic.cc
View File

@ -70,7 +70,7 @@ bool Net::Nic::handle_ip(Ethernet_frame *eth, Genode::size_t size) {
Ipv4_packet(size - sizeof(Ethernet_frame));
/* is it an UDP packet ? */
if (ip->protocol() == Udp_packet::IP_ID)
if (ip->protocol() == Ipv4_packet::Protocol::UDP)
{
Udp_packet *udp = new (ip->data<void>())
Udp_packet(size - sizeof(Ipv4_packet));

2
repos/os/src/server/nic_router/domain.cc
View File

@ -13,7 +13,7 @@
/* local includes */
#include <configuration.h>
#include <protocol_name.h>
#include <l3_protocol.h>
/* Genode includes */
#include <util/xml_node.h>

134
repos/os/src/server/nic_router/interface.cc
View File

@ -19,7 +19,7 @@
/* local includes */
#include <interface.h>
#include <configuration.h>
#include <protocol_name.h>
#include <l3_protocol.h>
using namespace Net;
using namespace Genode;
@ -54,13 +54,13 @@ static void _destroy_links(Link_side_tree &links,
}
static void _link_packet(uint8_t const prot,
void *const prot_base,
Link &link,
bool const client)
static void _link_packet(L3_protocol const prot,
void *const prot_base,
Link &link,
bool const client)
{
switch (prot) {
case Tcp_packet::IP_ID:
case L3_protocol::TCP:
if (client) {
static_cast<Tcp_link *>(&link)->client_packet(*(Tcp_packet *)(prot_base));
return;
@ -68,77 +68,77 @@ static void _link_packet(uint8_t const prot,
static_cast<Tcp_link *>(&link)->server_packet(*(Tcp_packet *)(prot_base));
return;
}
case Udp_packet::IP_ID:
case L3_protocol::UDP:
static_cast<Udp_link *>(&link)->packet();
return;
default: throw Interface::Bad_transport_protocol(); }
}
static void _update_checksum(uint8_t const prot,
static void _update_checksum(L3_protocol const prot,
void *const prot_base,
size_t const prot_size,
Ipv4_address const src,
Ipv4_address const dst)
{
switch (prot) {
case Tcp_packet::IP_ID:
case L3_protocol::TCP:
((Tcp_packet *)prot_base)->update_checksum(src, dst, prot_size);
return;
case Udp_packet::IP_ID:
case L3_protocol::UDP:
((Udp_packet *)prot_base)->update_checksum(src, dst);
return;
default: throw Interface::Bad_transport_protocol(); }
}
static Port _dst_port(uint8_t const prot, void *const prot_base)
static Port _dst_port(L3_protocol const prot, void *const prot_base)
{
switch (prot) {
case Tcp_packet::IP_ID: return (*(Tcp_packet *)prot_base).dst_port();
case Udp_packet::IP_ID: return (*(Udp_packet *)prot_base).dst_port();
case L3_protocol::TCP: return (*(Tcp_packet *)prot_base).dst_port();
case L3_protocol::UDP: return (*(Udp_packet *)prot_base).dst_port();
default: throw Interface::Bad_transport_protocol(); }
}
static void _dst_port(uint8_t const prot,
void *const prot_base,
Port const port)
static void _dst_port(L3_protocol const prot,
void *const prot_base,
Port const port)
{
switch (prot) {
case Tcp_packet::IP_ID: (*(Tcp_packet *)prot_base).dst_port(port); return;
case Udp_packet::IP_ID: (*(Udp_packet *)prot_base).dst_port(port); return;
case L3_protocol::TCP: (*(Tcp_packet *)prot_base).dst_port(port); return;
case L3_protocol::UDP: (*(Udp_packet *)prot_base).dst_port(port); return;
default: throw Interface::Bad_transport_protocol(); }
}
static Port _src_port(uint8_t const prot, void *const prot_base)
static Port _src_port(L3_protocol const prot, void *const prot_base)
{
switch (prot) {
case Tcp_packet::IP_ID: return (*(Tcp_packet *)prot_base).src_port();
case Udp_packet::IP_ID: return (*(Udp_packet *)prot_base).src_port();
case L3_protocol::TCP: return (*(Tcp_packet *)prot_base).src_port();
case L3_protocol::UDP: return (*(Udp_packet *)prot_base).src_port();
default: throw Interface::Bad_transport_protocol(); }
}
static void _src_port(uint8_t const prot,
void *const prot_base,
Port const port)
static void _src_port(L3_protocol const prot,
void *const prot_base,
Port const port)
{
switch (prot) {
case Tcp_packet::IP_ID: ((Tcp_packet *)prot_base)->src_port(port); return;
case Udp_packet::IP_ID: ((Udp_packet *)prot_base)->src_port(port); return;
case L3_protocol::TCP: ((Tcp_packet *)prot_base)->src_port(port); return;
case L3_protocol::UDP: ((Udp_packet *)prot_base)->src_port(port); return;
default: throw Interface::Bad_transport_protocol(); }
}
static void *_prot_base(uint8_t const prot,
size_t const prot_size,
Ipv4_packet &ip)
static void *_prot_base(L3_protocol const prot,
size_t const prot_size,
Ipv4_packet &ip)
{
switch (prot) {
case Tcp_packet::IP_ID: return new (ip.data<void>()) Tcp_packet(prot_size);
case Udp_packet::IP_ID: return new (ip.data<void>()) Udp_packet(prot_size);
case L3_protocol::TCP: return new (ip.data<void>()) Tcp_packet(prot_size);
case L3_protocol::UDP: return new (ip.data<void>()) Udp_packet(prot_size);
default: throw Interface::Bad_transport_protocol(); }
}
@ -147,12 +147,12 @@ static void *_prot_base(uint8_t const prot,
** Interface **
***************/
void Interface::_pass_prot(Ethernet_frame &eth,
size_t const eth_size,
Ipv4_packet &ip,
uint8_t const prot,
void *const prot_base,
size_t const prot_size)
void Interface::_pass_prot(Ethernet_frame &eth,
size_t const eth_size,
Ipv4_packet &ip,
L3_protocol const prot,
void *const prot_base,
size_t const prot_size)
{
_update_checksum(prot, prot_base, prot_size, ip.src(), ip.dst());
_pass_ip(eth, eth_size, ip);
@ -168,33 +168,35 @@ void Interface::_pass_ip(Ethernet_frame &eth,
}
Forward_rule_tree &Interface::_forward_rules(uint8_t const prot) const
Forward_rule_tree &
Interface::_forward_rules(L3_protocol const prot) const
{
switch (prot) {
case Tcp_packet::IP_ID: return _domain.tcp_forward_rules();
case Udp_packet::IP_ID: return _domain.udp_forward_rules();
case L3_protocol::TCP: return _domain.tcp_forward_rules();
case L3_protocol::UDP: return _domain.udp_forward_rules();
default: throw Bad_transport_protocol(); }
}
Transport_rule_list &Interface::_transport_rules(uint8_t const prot) const
Transport_rule_list &
Interface::_transport_rules(L3_protocol const prot) const
{
switch (prot) {
case Tcp_packet::IP_ID: return _domain.tcp_rules();
case Udp_packet::IP_ID: return _domain.udp_rules();
case L3_protocol::TCP: return _domain.tcp_rules();
case L3_protocol::UDP: return _domain.udp_rules();
default: throw Bad_transport_protocol(); }
}
void
Interface::_new_link(uint8_t const protocol,
Interface::_new_link(L3_protocol const protocol,
Link_side_id const &local,
Pointer<Port_allocator_guard> const remote_port_alloc,
Interface &remote_interface,
Link_side_id const &remote)
{
switch (protocol) {
case Tcp_packet::IP_ID:
case L3_protocol::TCP:
{
Tcp_link &link = *new (_alloc)
Tcp_link(*this, local, remote_port_alloc, remote_interface,
@ -208,7 +210,7 @@ Interface::_new_link(uint8_t const protocol,
}
return;
}
case Udp_packet::IP_ID:
case L3_protocol::UDP:
{
Udp_link &link = *new (_alloc)
Udp_link(*this, local, remote_port_alloc, remote_interface,
@ -226,32 +228,32 @@ Interface::_new_link(uint8_t const protocol,
}
Link_side_tree &Interface::_links(uint8_t const protocol)
Link_side_tree &Interface::_links(L3_protocol const protocol)
{
switch (protocol) {
case Tcp_packet::IP_ID: return _tcp_links;
case Udp_packet::IP_ID: return _udp_links;
case L3_protocol::TCP: return _tcp_links;
case L3_protocol::UDP: return _udp_links;
default: throw Bad_transport_protocol(); }
}
void Interface::link_closed(Link &link, uint8_t const prot)
void Interface::link_closed(Link &link, L3_protocol const prot)
{
_closed_links(prot).insert(&link);
}
void Interface::dissolve_link(Link_side &link_side, uint8_t const prot)
void Interface::dissolve_link(Link_side &link_side, L3_protocol const prot)
{
_links(prot).remove(&link_side);
}
Link_list &Interface::_closed_links(uint8_t const protocol)
Link_list &Interface::_closed_links(L3_protocol const protocol)
{
switch (protocol) {
case Tcp_packet::IP_ID: return _closed_tcp_links;
case Udp_packet::IP_ID: return _closed_udp_links;
case L3_protocol::TCP: return _closed_tcp_links;
case L3_protocol::UDP: return _closed_udp_links;
default: throw Bad_transport_protocol(); }
}
@ -273,14 +275,14 @@ void Interface::_adapt_eth(Ethernet_frame &eth,
}
void Interface::_nat_link_and_pass(Ethernet_frame &eth,
size_t const eth_size,
Ipv4_packet &ip,
uint8_t const prot,
void *const prot_base,
size_t const prot_size,
Link_side_id const &local,
Interface &interface)
void Interface::_nat_link_and_pass(Ethernet_frame &eth,
size_t const eth_size,
Ipv4_packet &ip,
L3_protocol const prot,
void *const prot_base,
size_t const prot_size,
Link_side_id const &local,
Interface &interface)
{
Pointer<Port_allocator_guard> remote_port_alloc;
try {
@ -313,7 +315,7 @@ void Interface::_handle_ip(Ethernet_frame &eth,
/* try to route via transport layer rules */
try {
uint8_t const prot = ip.protocol();
L3_protocol const prot = ip.protocol();
size_t const prot_size = ip.total_length() - ip.header_length() * 4;
void *const prot_base = _prot_base(prot, prot_size, ip);
Link_side_id const local = { ip.src(), _src_port(prot, prot_base),
@ -327,7 +329,7 @@ void Interface::_handle_ip(Ethernet_frame &eth,
Link_side &remote_side = client ? link.server() : link.client();
Interface &interface = remote_side.interface();
if(_config().verbose()) {
log("Using ", protocol_name(prot), " link: ", link); }
log("Using ", l3_protocol_name(prot), " link: ", link); }
_adapt_eth(eth, eth_size, remote_side.src_ip(), pkt, interface);
ip.src(remote_side.dst_ip());
@ -349,7 +351,7 @@ void Interface::_handle_ip(Ethernet_frame &eth,
Interface &interface = rule.domain().interface().deref();
if(_config().verbose()) {
log("Using forward rule: ", protocol_name(prot), " ", rule); }
log("Using forward rule: ", l3_protocol_name(prot), " ", rule); }
_adapt_eth(eth, eth_size, rule.to(), pkt, interface);
ip.dst(rule.to());
@ -369,7 +371,7 @@ void Interface::_handle_ip(Ethernet_frame &eth,
Interface &interface = permit_rule.domain().interface().deref();
if(_config().verbose()) {
log("Using ", protocol_name(prot), " rule: ", transport_rule,
log("Using ", l3_protocol_name(prot), " rule: ", transport_rule,
" ", permit_rule); }
_adapt_eth(eth, eth_size, local.dst_ip, pkt, interface);

19
repos/os/src/server/nic_router/interface.h
View File

@ -18,6 +18,7 @@
#include <link.h>
#include <arp_cache.h>
#include <arp_waiter.h>
#include <l3_protocol.h>
/* Genode includes */
#include <nic_session/nic_session.h>
@ -63,15 +64,15 @@ class Net::Interface
Link_list _closed_tcp_links;
Link_list _closed_udp_links;
void _new_link(Genode::uint8_t const protocol,
void _new_link(L3_protocol const protocol,
Link_side_id const &local_id,
Pointer<Port_allocator_guard> const remote_port_alloc,
Interface &remote_interface,
Link_side_id const &remote_id);
Forward_rule_tree &_forward_rules(Genode::uint8_t const prot) const;
Forward_rule_tree &_forward_rules(L3_protocol const prot) const;
Transport_rule_list &_transport_rules(Genode::uint8_t const prot) const;
Transport_rule_list &_transport_rules(L3_protocol const prot) const;
void _handle_arp(Ethernet_frame &eth, Genode::size_t const eth_size);
@ -94,7 +95,7 @@ class Net::Interface
void _nat_link_and_pass(Ethernet_frame &eth,
Genode::size_t const eth_size,
Ipv4_packet &ip,
Genode::uint8_t const prot,
L3_protocol const prot,
void *const prot_base,
Genode::size_t const prot_size,
Link_side_id const &local_id,
@ -107,7 +108,7 @@ class Net::Interface
void _pass_prot(Ethernet_frame &eth,
Genode::size_t const eth_size,
Ipv4_packet &ip,
Genode::uint8_t const prot,
L3_protocol const prot,
void *const prot_base,
Genode::size_t const prot_size);
@ -117,9 +118,9 @@ class Net::Interface
void _continue_handle_eth(Packet_descriptor const &pkt);
Link_list &_closed_links(Genode::uint8_t const protocol);
Link_list &_closed_links(L3_protocol const protocol);
Link_side_tree &_links(Genode::uint8_t const protocol);
Link_side_tree &_links(L3_protocol const protocol);
Configuration &_config() const;
@ -162,9 +163,9 @@ class Net::Interface
~Interface();
void link_closed(Link &link, Genode::uint8_t const prot);
void link_closed(Link &link, L3_protocol const prot);
void dissolve_link(Link_side &link_side, Genode::uint8_t const prot);
void dissolve_link(Link_side &link_side, L3_protocol const prot);
/*********

10
repos/os/src/server/nic_router/protocol_name.cc → repos/os/src/server/nic_router/l3_protocol.cc
View File

@ -1,5 +1,5 @@
/*
* \brief Provide protocol names as Genode Cstring objects
* \brief Utilities regarding layer 3 protocols in general
* \author Martin Stein
* \date 2016-08-19
*/
@ -12,7 +12,7 @@
*/
/* local includes */
#include <protocol_name.h>
#include <l3_protocol.h>
#include <interface.h>
/* Genode includes */
@ -30,10 +30,10 @@ Cstring const &Net::udp_name() { return _udp_name; }
Cstring const &Net::tcp_name() { return _tcp_name; }
Cstring const &Net::protocol_name(uint8_t protocol)
Cstring const &Net::l3_protocol_name(L3_protocol protocol)
{
switch (protocol) {
case Tcp_packet::IP_ID: return tcp_name();
case Udp_packet::IP_ID: return udp_name();
case L3_protocol::TCP: return tcp_name();
case L3_protocol::UDP: return udp_name();
default: throw Interface::Bad_transport_protocol(); }
}

13
repos/os/src/server/nic_router/protocol_name.h → repos/os/src/server/nic_router/l3_protocol.h
View File

@ -1,5 +1,5 @@
/*
* \brief Provide protocol names as Genode Cstring objects
* \brief Utilities regarding layer 3 protocols in general
* \author Martin Stein
* \date 2016-08-19
*/
@ -11,19 +11,22 @@
* under the terms of the GNU Affero General Public License version 3.
*/
#ifndef _PROTOCOL_NAME_H_
#define _PROTOCOL_NAME_H_
#ifndef _L3_PROTOCOL_H_
#define _L3_PROTOCOL_H_
/* Genode includes */
#include <net/ipv4.h>
#include <base/stdint.h>
namespace Genode { class Cstring; }
namespace Net {
using L3_protocol = Ipv4_packet::Protocol;
Genode::Cstring const &tcp_name();
Genode::Cstring const &udp_name();
Genode::Cstring const &protocol_name(Genode::uint8_t protocol);
Genode::Cstring const &l3_protocol_name(L3_protocol protocol);
}
#endif /* _PROTOCOL_NAME_H_ */
#endif /* _L3_PROTOCOL_H_ */

12
repos/os/src/server/nic_router/link.cc
View File

@ -18,7 +18,7 @@
#include <link.h>
#include <interface.h>
#include <configuration.h>
#include <protocol_name.h>
#include <l3_protocol.h>
using namespace Net;
using namespace Genode;
@ -117,7 +117,7 @@ Link::Link(Interface &cln_interface,
Link_side_id const &srv_id,
Timer::Connection &timer,
Configuration &config,
uint8_t const protocol)
L3_protocol const protocol)
:
_config(config),
_client(cln_interface, cln_id, *this),
@ -143,12 +143,12 @@ void Link::dissolve()
_client._interface.dissolve_link(_client, _protocol);
_server._interface.dissolve_link(_server, _protocol);
if (_config.verbose()) {
log("Dissolve ", protocol_name(_protocol), " link: ", *this); }
log("Dissolve ", l3_protocol_name(_protocol), " link: ", *this); }
try {
_server_port_alloc.deref().free(_server.dst_port());
if (_config.verbose()) {
log("Free ", protocol_name(_protocol),
log("Free ", l3_protocol_name(_protocol),
" port ", _server.dst_port(),
" at ", _server.interface(),
" that was used by ", _client.interface());
@ -169,7 +169,7 @@ Tcp_link::Tcp_link(Interface &cln_interface,
Link_side_id const &srv_id,
Timer::Connection &timer,
Configuration &config,
uint8_t const protocol)
L3_protocol const protocol)
:
Link(cln_interface, cln_id, srv_port_alloc, srv_interface, srv_id, timer,
config, protocol)
@ -230,7 +230,7 @@ Udp_link::Udp_link(Interface &cln_interface,
Link_side_id const &srv_id,
Timer::Connection &timer,
Configuration &config,
uint8_t const protocol)
L3_protocol const protocol)
:
Link(cln_interface, cln_id, srv_port_alloc, srv_interface, srv_id, timer,
config, protocol)

9
repos/os/src/server/nic_router/link.h
View File

@ -23,6 +23,7 @@
/* local includes */
#include <pointer.h>
#include <l3_protocol.h>
namespace Net {
@ -131,7 +132,7 @@ class Net::Link : public Link_list::Element
Link_side _server;
Timer::One_shot_timeout<Link> _close_timeout;
Genode::Microseconds const _close_timeout_us;
Genode::uint8_t const _protocol;
L3_protocol const _protocol;
void _handle_close_timeout(Genode::Duration);
@ -148,7 +149,7 @@ class Net::Link : public Link_list::Element
Link_side_id const &srv_id,
Timer::Connection &timer,
Configuration &config,
Genode::uint8_t const protocol);
L3_protocol const protocol);
void dissolve();
@ -190,7 +191,7 @@ class Net::Tcp_link : public Link
Link_side_id const &srv_id,
Timer::Connection &timer,
Configuration &config,
Genode::uint8_t const protocol);
L3_protocol const protocol);
void client_packet(Tcp_packet &tcp);
@ -207,7 +208,7 @@ struct Net::Udp_link : Link
Link_side_id const &srv_id,
Timer::Connection &timer,
Configuration &config,
Genode::uint8_t const protocol);
L3_protocol const protocol);
void packet() { _packet(); }
};

6
repos/os/src/server/nic_router/nat_rule.cc
View File

@ -75,10 +75,10 @@ void Nat_rule::print(Output &output) const
}
Port_allocator_guard &Nat_rule::port_alloc(uint8_t const prot)
Port_allocator_guard &Nat_rule::port_alloc(L3_protocol const prot)
{
switch (prot) {
case Tcp_packet::IP_ID: return _tcp_port_alloc;
case Udp_packet::IP_ID: return _udp_port_alloc;
case L3_protocol::TCP: return _tcp_port_alloc;
case L3_protocol::UDP: return _udp_port_alloc;
default: throw Interface::Bad_transport_protocol(); }
}

3
repos/os/src/server/nic_router/nat_rule.h
View File

@ -17,6 +17,7 @@
/* local includes */
#include <port_allocator.h>
#include <leaf_rule.h>
#include <l3_protocol.h>
/* Genode includes */
#include <util/avl_string.h>
@ -47,7 +48,7 @@ class Net::Nat_rule : public Leaf_rule,
Nat_rule &find_by_domain(Domain &domain);
Port_allocator_guard &port_alloc(Genode::uint8_t const prot);
Port_allocator_guard &port_alloc(L3_protocol const prot);
/*********

2
repos/os/src/server/nic_router/target.mk
View File

@ -6,7 +6,7 @@ SRC_CC += arp_waiter.cc ip_rule.cc
SRC_CC += component.cc port_allocator.cc forward_rule.cc
SRC_CC += nat_rule.cc mac_allocator.cc main.cc
SRC_CC += uplink.cc interface.cc arp_cache.cc configuration.cc
SRC_CC += domain.cc protocol_name.cc direct_rule.cc link.cc
SRC_CC += domain.cc l3_protocol.cc direct_rule.cc link.cc
SRC_CC += transport_rule.cc leaf_rule.cc permit_rule.cc
INC_DIR += $(PRG_DIR)