TheCloud/thor-os
1
0
Fork 0
mirror of https://github.com/wichtounet/thor-os.git synced 2025-09-14 06:56:51 -04:00
Code Issues Packages Projects Releases Wiki Activity

Move packet out of ethernet

Browse Source
This commit is contained in:
Baptiste Wicht 2016-09-29 09:47:05 +02:00
parent 031352ea34
commit 56e865c6de
No known key found for this signature in database
GPG Key ID: C5566B6C7F884532
23 changed files with 97 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
kernel/include/net/arp_layer.hpp
View File

@ -14,7 +14,7 @@
#include "tlib/net_constants.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
#include "net/interface.hpp"
#include "net/arp_cache.hpp"
@ -55,7 +55,7 @@ struct layer {
* \param interface The interface on which the packet was received
* \param packet The packet to decode
*/
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
void decode(network::interface_descriptor& interface, network::packet& packet);
network::arp::cache& get_cache();

6
kernel/include/net/dhcp_layer.hpp
View File

@ -13,7 +13,7 @@
#include <atomic.hpp>
#include "net/interface.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
namespace network {
@ -66,7 +66,7 @@ struct layer {
* \param interface The interface on which the packet was received
* \param packet The packet to decode
*/
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
void decode(network::interface_descriptor& interface, network::packet& packet);
/*!
* \brief Request an IP address on the network
@ -78,7 +78,7 @@ private:
network::udp::layer* parent;
std::atomic<bool> listening;
circular_buffer<network::ethernet::packet, 16> packets;
circular_buffer<network::packet, 16> packets;
condition_variable listen_queue;
};

8
kernel/include/net/dns_layer.hpp
View File

@ -12,7 +12,7 @@
#include "tlib/net_constants.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
#include "net/interface.hpp"
namespace network {
@ -36,7 +36,7 @@ struct layer {
* \param interface The interface on which the packet was received
* \param packet The packet to decode
*/
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
void decode(network::interface_descriptor& interface, network::packet& packet);
/*!
* \brief Prepare a packet for the user
@ -45,7 +45,7 @@ struct layer {
* \param descriptor The packet descriptor
* \return the prepared packet or an error
*/
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor);
std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor);
/*!
* \brief Finalize a prepared packet
@ -53,7 +53,7 @@ struct layer {
* \param p The packet to finalize
* \return nothing or an error
*/
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::packet& p);
private:
network::udp::layer* parent;

2
kernel/include/net/ethernet_layer.hpp
View File

@ -14,7 +14,7 @@
#include "tlib/net_constants.hpp"
#include "net/interface.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
namespace network {

10
kernel/include/net/icmp_layer.hpp
View File

@ -14,7 +14,7 @@
#include "tlib/net_constants.hpp"
#include "net/interface.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
namespace network {
@ -37,7 +37,7 @@ struct layer {
* \param interface The interface on which the packet was received
* \param packet The packet to decode
*/
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
void decode(network::interface_descriptor& interface, network::packet& packet);
/*!
* \brief Prepare a packet for the kernel
@ -45,7 +45,7 @@ struct layer {
* \param descriptor The packet descriptor
* \return the prepared packet or an error
*/
std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor);
std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor);
/*!
* \brief Prepare a packet for the user
@ -54,7 +54,7 @@ struct layer {
* \param descriptor The packet descriptor
* \return the prepared packet or an error
*/
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor);
std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor);
/*!
* \brief Finalize a prepared packet
@ -62,7 +62,7 @@ struct layer {
* \param p The packet to finalize
* \return nothing or an error
*/
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::packet& p);
private:
network::ip::layer* parent;

10
kernel/include/net/interface.hpp
View File

@ -17,7 +17,7 @@
#include "conc/semaphore.hpp"
#include "conc/deferred_unique_semaphore.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
#include "tlib/net_constants.hpp"
@ -49,15 +49,15 @@ struct interface_descriptor {
mutable semaphore tx_sem; ///< Semaphore for transmission
mutable deferred_unique_semaphore rx_sem; ///< Semaphore for reception
circular_buffer<ethernet::packet, 32> rx_queue; ///< The reception queue
circular_buffer<ethernet::packet, 32> tx_queue; ///< The transmission queue
circular_buffer<packet, 32> rx_queue; ///< The reception queue
circular_buffer<packet, 32> tx_queue; ///< The transmission queue
void (*hw_send)(interface_descriptor&, ethernet::packet& p); ///< Driver hardware send function
void (*hw_send)(interface_descriptor&, packet& p); ///< Driver hardware send function
/*!
* \brief Send a packet through this interface
*/
void send(ethernet::packet& p){
void send(packet& p){
std::lock_guard<mutex> l(tx_lock);
tx_queue.push(p);
tx_sem.unlock();

10
kernel/include/net/ip_layer.hpp
View File

@ -14,7 +14,7 @@
#include "tlib/net_constants.hpp"
#include "net/interface.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
namespace network {
@ -59,7 +59,7 @@ struct layer {
* \param interface The interface on which the packet was received
* \param packet The packet to decode
*/
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
void decode(network::interface_descriptor& interface, network::packet& packet);
/*!
* \brief Prepare a packet for the kernel
@ -67,7 +67,7 @@ struct layer {
* \param descriptor The packet descriptor
* \return the prepared packet or an error
*/
std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& desc);
std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& desc);
/*!
* \brief Prepare a packet for the user
@ -76,7 +76,7 @@ struct layer {
* \param descriptor The packet descriptor
* \return the prepared packet or an error
*/
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* desc);
std::expected<network::packet> user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* desc);
/*!
* \brief Finalize a prepared packet
@ -84,7 +84,7 @@ struct layer {
* \param p The packet to finalize
* \return nothing or an error
*/
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::packet& p);
void register_icmp_layer(network::icmp::layer* layer);
void register_arp_layer(network::arp::layer* layer);

4
kernel/include/net/network.hpp
View File

@ -15,7 +15,7 @@
#include "tlib/net_constants.hpp"
#include "net/interface.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
namespace network {
@ -229,7 +229,7 @@ std::expected<size_t> wait_for_packet(char* buffer, socket_fd_t socket_fd, size_
* \param packet The packet to propagate
* \param protocol The destination protocol
*/
void propagate_packet(const ethernet::packet& packet, socket_protocol protocol);
void propagate_packet(const packet& packet, socket_protocol protocol);
/*!
* \brief Return the IP address of the DNS server

10
kernel/include/net/ethernet_packet.hpp → kernel/include/net/packet.hpp
View File

@ -5,8 +5,8 @@
// http://www.opensource.org/licenses/MIT)
//=======================================================================
#ifndef NET_ETHERNET_PACKET_H
#define NET_ETHERNET_PACKET_H
#ifndef NET_PACKET_H
#define NET_PACKET_H
#include <types.hpp>
@ -14,10 +14,8 @@
namespace network {
namespace ethernet {
/*!
* \brief A packet on the ethernet layer
* \brief A network packet.
*/
struct packet {
// Set from the beginning
@ -45,8 +43,6 @@ struct packet {
}
};
} // end of ethernet namespace
} // end of network namespace
#endif

12
kernel/include/net/socket.hpp
View File

@ -18,7 +18,7 @@
#include "conc/condition_variable.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
#include "assert.hpp"
@ -36,9 +36,9 @@ struct socket {
bool listen; ///< Indicates if the socket is listening to packets
void* connection_data = nullptr; ///< Optional pointer to the connection data (TCP/UDP)
std::vector<network::ethernet::packet> packets; ///< Packets that are prepared with their fd
std::vector<network::packet> packets; ///< Packets that are prepared with their fd
circular_buffer<network::ethernet::packet, 32> listen_packets; ///< The packets that wait to be read in listen mode
circular_buffer<network::packet, 32> listen_packets; ///< The packets that wait to be read in listen mode
condition_variable listen_queue; ///< Condition variable to wait for packets
socket() {}
@ -63,7 +63,7 @@ struct socket {
* \brief Register a new packet into the socket
* \return The file descriptor of the packet
*/
size_t register_packet(network::ethernet::packet packet) {
size_t register_packet(network::packet packet) {
auto fd = next_fd++;
packet.fd = fd;
@ -89,7 +89,7 @@ struct socket {
/*!
* \brief Returns the packet with the given file descriptor
*/
network::ethernet::packet& get_packet(size_t fd) {
network::packet& get_packet(size_t fd) {
for (auto& packet : packets) {
if (packet.fd == fd) {
return packet;
@ -103,7 +103,7 @@ struct socket {
* \brief Removes the packet with the given file descriptor
*/
void erase_packet(size_t fd) {
packets.erase(std::remove_if(packets.begin(), packets.end(), [fd](network::ethernet::packet& packet) {
packets.erase(std::remove_if(packets.begin(), packets.end(), [fd](network::packet& packet) {
return packet.fd == fd;
}), packets.end());
}

16
kernel/include/net/tcp_layer.hpp
View File

@ -14,7 +14,7 @@
#include "conc/condition_variable.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
#include "net/connection_handler.hpp"
#include "net/interface.hpp"
#include "net/socket.hpp"
@ -34,7 +34,7 @@ struct tcp_connection {
std::atomic<bool> listening; ///< Indicates if a kernel thread is listening on this connection
condition_variable queue; ///< The listening queue
circular_buffer<network::ethernet::packet, 32> packets; ///< The packets for the listening queue
circular_buffer<network::packet, 32> packets; ///< The packets for the listening queue
bool connected = false; ///< Indicate if the connection is connnected
bool server = false; ///< Indicate if the connection is a server (true) or a client (false)
@ -63,7 +63,7 @@ struct layer {
* \param interface The interface on which the packet was received
* \param packet The packet to decode
*/
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
void decode(network::interface_descriptor& interface, network::packet& packet);
/*!
* \brief Prepare a packet for the user
@ -72,7 +72,7 @@ struct layer {
* \param descriptor The packet descriptor
* \return the prepared packet or an error
*/
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor);
std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor);
/*!
* \brief Finalize a prepared packet
@ -80,7 +80,7 @@ struct layer {
* \param p The packet to finalize
* \return nothing or an error
*/
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::ethernet::packet& p);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::packet& p);
std::expected<void> send(char* target_buffer, network::socket& socket, const char* buffer, size_t n);
std::expected<size_t> receive(char* buffer, network::socket& socket, size_t n);
@ -93,9 +93,9 @@ struct layer {
std::expected<void> disconnect(network::socket& socket);
private:
std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size);
std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, tcp_connection& connection, size_t payload_size);
std::expected<void> finalize_packet_direct(network::interface_descriptor& interface, network::ethernet::packet& p);
std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size);
std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, tcp_connection& connection, size_t payload_size);
std::expected<void> finalize_packet_direct(network::interface_descriptor& interface, network::packet& p);
network::ip::layer* parent;

12
kernel/include/net/udp_layer.hpp
View File

@ -14,7 +14,7 @@
#include "tlib/net_constants.hpp"
#include "net/interface.hpp"
#include "net/ethernet_packet.hpp"
#include "net/packet.hpp"
#include "net/connection_handler.hpp"
#include "net/socket.hpp"
@ -71,7 +71,7 @@ struct layer {
* \param interface The interface on which the packet was received
* \param packet The packet to decode
*/
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
void decode(network::interface_descriptor& interface, network::packet& packet);
/*!
* \brief Prepare a packet for the kernel
@ -79,7 +79,7 @@ struct layer {
* \param descriptor The packet descriptor
* \return the prepared packet or an error
*/
std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, const kernel_packet_descriptor& descriptor);
std::expected<network::packet> kernel_prepare_packet(network::interface_descriptor& interface, const kernel_packet_descriptor& descriptor);
/*!
* \brief Prepare a packet for the user
@ -88,9 +88,9 @@ struct layer {
* \param descriptor The packet descriptor
* \return the prepared packet or an error
*/
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor);
std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor);
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::socket& sock, const network::udp::packet_descriptor* descriptor, network::inet_address* address);
std::expected<network::packet> user_prepare_packet(char* buffer, network::socket& sock, const network::udp::packet_descriptor* descriptor, network::inet_address* address);
/*!
* \brief Finalize a prepared packet
@ -98,7 +98,7 @@ struct layer {
* \param p The packet to finalize
* \return nothing or an error
*/
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::packet& p);
std::expected<size_t> client_bind(network::socket& socket, size_t server_port, network::ip::address server);
std::expected<void> server_bind(network::socket& socket, size_t server_port, network::ip::address server);

2
kernel/src/drivers/loopback.cpp
View File

@ -22,7 +22,7 @@ struct loopback_t {
network::interface_descriptor* interface;
};
void send_packet(network::interface_descriptor& interface, network::ethernet::packet& packet){
void send_packet(network::interface_descriptor& interface, network::packet& packet){
logging::logf(logging::log_level::TRACE, "loopback: Transmit packet\n");
auto packet_buffer = new char[packet.payload_size];

4
kernel/src/drivers/rtl8139.cpp
View File

@ -131,7 +131,7 @@ void packet_handler(interrupt::syscall_regs*, void* data){
std::copy_n(packet_payload, packet_only_length, packet_buffer);
network::ethernet::packet packet(packet_buffer, packet_only_length);
network::packet packet(packet_buffer, packet_only_length);
interface.rx_queue.push(packet);
interface.rx_sem.notify();
@ -186,7 +186,7 @@ void packet_handler(interrupt::syscall_regs*, void* data){
}
}
void send_packet(network::interface_descriptor& interface, network::ethernet::packet& packet){
void send_packet(network::interface_descriptor& interface, network::packet& packet){
logging::logf(logging::log_level::TRACE, "rtl8139: Start transmitting packet\n");
auto* ether_header = reinterpret_cast<network::ethernet::header*>(packet.payload);

2
kernel/src/net/arp_layer.cpp
View File

@ -52,7 +52,7 @@ network::arp::layer::layer(network::ethernet::layer* parent) : parent(parent), _
parent->register_arp_layer(this);
}
void network::arp::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet){
void network::arp::layer::decode(network::interface_descriptor& interface, network::packet& packet){
packet.tag(1, packet.index);
header* arp_header = reinterpret_cast<header*>(packet.payload + packet.index);

4
kernel/src/net/dhcp_layer.cpp
View File

@ -15,7 +15,7 @@
namespace {
void prepare_packet(network::ethernet::packet& packet, network::interface_descriptor& interface) {
void prepare_packet(network::packet& packet, network::interface_descriptor& interface) {
packet.tag(3, packet.index);
// Set the DHCP header
@ -54,7 +54,7 @@ network::dhcp::layer::layer(network::udp::layer* parent) : parent(parent) {
parent->register_dhcp_layer(this);
}
void network::dhcp::layer::decode(network::interface_descriptor& /*interface*/, network::ethernet::packet& packet) {
void network::dhcp::layer::decode(network::interface_descriptor& /*interface*/, network::packet& packet) {
packet.tag(3, packet.index);
logging::logf(logging::log_level::TRACE, "dhcp: Start DHCP packet handling\n");

10
kernel/src/net/dns_layer.cpp
View File

@ -26,7 +26,7 @@ using flag_ra = std::bit_field<uint16_t, uint8_t, 7, 1>;
using flag_zeroes = std::bit_field<uint16_t, uint8_t, 4, 3>;
using flag_rcode = std::bit_field<uint16_t, uint8_t, 0, 4>;
void prepare_packet_query(network::ethernet::packet& packet, uint16_t identification) {
void prepare_packet_query(network::packet& packet, uint16_t identification) {
packet.tag(3, packet.index);
// Set the DNS header
@ -91,7 +91,7 @@ network::dns::layer::layer(network::udp::layer* parent) : parent(parent) {
parent->register_dns_layer(this);
}
void network::dns::layer::decode(network::interface_descriptor& /*interface*/, network::ethernet::packet& packet) {
void network::dns::layer::decode(network::interface_descriptor& /*interface*/, network::packet& packet) {
packet.tag(3, packet.index);
auto* dns_header = reinterpret_cast<header*>(packet.payload + packet.index);
@ -199,10 +199,10 @@ void network::dns::layer::decode(network::interface_descriptor& /*interface*/, n
// Note: Propagate is handled by UDP connections
}
std::expected<network::ethernet::packet> network::dns::layer::user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor) {
std::expected<network::packet> network::dns::layer::user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor) {
// Check the packet descriptor
if(!descriptor->query){
return std::make_unexpected<network::ethernet::packet>(std::ERROR_SOCKET_INVALID_PACKET_DESCRIPTOR);
return std::make_unexpected<network::packet>(std::ERROR_SOCKET_INVALID_PACKET_DESCRIPTOR);
}
// Ask the UDP layer to craft a packet
@ -216,7 +216,7 @@ std::expected<network::ethernet::packet> network::dns::layer::user_prepare_packe
return packet;
}
std::expected<void> network::dns::layer::finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p) {
std::expected<void> network::dns::layer::finalize_packet(network::interface_descriptor& interface, network::packet& p) {
p.index -= sizeof(header);
// Give the packet to the UDP layer for finalization

10
kernel/src/net/ethernet_layer.cpp
View File

@ -45,7 +45,7 @@ uint16_t type_to_code(network::ethernet::ether_type type){
return 0x0;
}
void prepare_packet(network::ethernet::packet& p, network::interface_descriptor& interface, const network::ethernet::packet_descriptor& descriptor){
void prepare_packet(network::packet& p, network::interface_descriptor& interface, const network::ethernet::packet_descriptor& descriptor){
p.tag(0, 0);
p.index = sizeof(network::ethernet::header);
p.interface = interface.id;
@ -124,20 +124,20 @@ void network::ethernet::layer::decode(network::interface_descriptor& interface,
logging::logf(logging::log_level::TRACE, "ethernet: Finished decoding packet\n");
}
std::expected<network::ethernet::packet> network::ethernet::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
std::expected<network::packet> network::ethernet::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
auto total_size = descriptor.size + sizeof(header);
network::ethernet::packet p(new char[total_size], total_size);
network::packet p(new char[total_size], total_size);
::prepare_packet(p, interface, descriptor);
return p;
}
std::expected<network::ethernet::packet> network::ethernet::layer::user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* descriptor){
std::expected<network::packet> network::ethernet::layer::user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* descriptor){
auto total_size = descriptor->size + sizeof(header);
network::ethernet::packet p(buffer, total_size);
network::packet p(buffer, total_size);
p.user = true;
::prepare_packet(p, interface, *descriptor);

10
kernel/src/net/icmp_layer.cpp
View File

@ -38,7 +38,7 @@ void compute_checksum(network::icmp::header* icmp_header, size_t payload_size){
icmp_header->checksum = ~value;
}
void prepare_packet(network::ethernet::packet& packet, network::icmp::type t, size_t code){
void prepare_packet(network::packet& packet, network::icmp::type t, size_t code){
packet.tag(2, packet.index);
// Set the ICMP header
@ -57,7 +57,7 @@ network::icmp::layer::layer(network::ip::layer* parent) : parent(parent) {
parent->register_icmp_layer(this);
}
void network::icmp::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet){
void network::icmp::layer::decode(network::interface_descriptor& interface, network::packet& packet){
packet.tag(2, packet.index);
logging::logf(logging::log_level::TRACE, "icmp: Start ICMP packet handling\n");
@ -116,7 +116,7 @@ void network::icmp::layer::decode(network::interface_descriptor& interface, netw
network::propagate_packet(packet, network::socket_protocol::ICMP);
}
std::expected<network::ethernet::packet> network::icmp::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
std::expected<network::packet> network::icmp::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
// Ask the IP layer to craft a packet
network::ip::packet_descriptor desc{sizeof(header) + descriptor.payload_size, descriptor.target_ip, 0x01};
auto packet = parent->kernel_prepare_packet(interface, desc);
@ -128,7 +128,7 @@ std::expected<network::ethernet::packet> network::icmp::layer::kernel_prepare_pa
return packet;
}
std::expected<network::ethernet::packet> network::icmp::layer::user_prepare_packet(char* buffer, network::socket& /*socket*/, const packet_descriptor* descriptor){
std::expected<network::packet> network::icmp::layer::user_prepare_packet(char* buffer, network::socket& /*socket*/, const packet_descriptor* descriptor){
auto& interface = network::select_interface(descriptor->target_ip);
// Ask the IP layer to craft a packet
@ -142,7 +142,7 @@ std::expected<network::ethernet::packet> network::icmp::layer::user_prepare_pack
return packet;
}
std::expected<void> network::icmp::layer::finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& packet){
std::expected<void> network::icmp::layer::finalize_packet(network::interface_descriptor& interface, network::packet& packet){
packet.index -= sizeof(header) - sizeof(uint32_t);
auto* icmp_header = reinterpret_cast<header*>(packet.payload + packet.index);

14
kernel/src/net/ip_layer.cpp
View File

@ -42,7 +42,7 @@ void compute_checksum(network::ip::header* header){
header->header_checksum = ~uint16_t(value);
}
void prepare_packet(network::ethernet::packet& packet, network::interface_descriptor& interface, size_t size, network::ip::address target_ip, size_t protocol){
void prepare_packet(network::packet& packet, network::interface_descriptor& interface, size_t size, network::ip::address target_ip, size_t protocol){
packet.tag(1, packet.index);
auto* ip_header = reinterpret_cast<network::ip::header*>(packet.payload + packet.index);
@ -93,7 +93,7 @@ network::ip::layer::layer(network::ethernet::layer* parent) : parent(parent) {
parent->register_ip_layer(this);
}
void network::ip::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet){
void network::ip::layer::decode(network::interface_descriptor& interface, network::packet& packet){
packet.tag(1, packet.index);
header* ip_header = reinterpret_cast<header*>(packet.payload + packet.index);
@ -138,11 +138,11 @@ void network::ip::layer::decode(network::interface_descriptor& interface, networ
}
}
std::expected<network::ethernet::packet> network::ip::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
std::expected<network::packet> network::ip::layer::kernel_prepare_packet(network::interface_descriptor& interface, const packet_descriptor& descriptor){
auto target_mac = get_target_mac(interface, descriptor.destination);
if(!target_mac){
return std::make_expected_from_error<network::ethernet::packet>(target_mac.error());
return std::make_expected_from_error<network::packet>(target_mac.error());
}
// Ask the ethernet layer to craft a packet
@ -156,11 +156,11 @@ std::expected<network::ethernet::packet> network::ip::layer::kernel_prepare_pack
return packet;
}
std::expected<network::ethernet::packet> network::ip::layer::user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* descriptor){
std::expected<network::packet> network::ip::layer::user_prepare_packet(char* buffer, network::interface_descriptor& interface, const packet_descriptor* descriptor){
auto target_mac = get_target_mac(interface, descriptor->destination);
if(!target_mac){
return std::make_expected_from_error<network::ethernet::packet>(target_mac.error());
return std::make_expected_from_error<network::packet>(target_mac.error());
}
// Ask the ethernet layer to craft a packet
@ -174,7 +174,7 @@ std::expected<network::ethernet::packet> network::ip::layer::user_prepare_packet
return packet;
}
std::expected<void> network::ip::layer::finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p){
std::expected<void> network::ip::layer::finalize_packet(network::interface_descriptor& interface, network::packet& p){
// Send the packet to the ethernet layer
return parent->finalize_packet(interface, p);
}

4
kernel/src/net/network.cpp
View File

@ -404,7 +404,7 @@ std::tuple<size_t, size_t> network::prepare_packet(socket_fd_t socket_fd, void*
auto& socket = scheduler::get_socket(socket_fd);
auto return_from_packet = [&socket](std::expected<network::ethernet::packet>& packet) -> std::tuple<size_t, size_t> {
auto return_from_packet = [&socket](std::expected<network::packet>& packet) -> std::tuple<size_t, size_t> {
if (packet) {
auto fd = socket.register_packet(*packet);
@ -926,7 +926,7 @@ std::expected<size_t> network::wait_for_packet(char* buffer, socket_fd_t socket_
return {packet.index};
}
void network::propagate_packet(const ethernet::packet& packet, socket_protocol protocol){
void network::propagate_packet(const packet& packet, socket_protocol protocol){
// TODO Need something better for this
for(size_t pid = 0; pid < scheduler::MAX_PROCESS; ++pid){

20
kernel/src/net/tcp_layer.cpp
View File

@ -35,7 +35,7 @@ using flag_rst = std::bit_field<uint16_t, uint8_t, 2, 1>;
using flag_syn = std::bit_field<uint16_t, uint8_t, 1, 1>;
using flag_fin = std::bit_field<uint16_t, uint8_t, 0, 1>;
void compute_checksum(network::ethernet::packet& packet) {
void compute_checksum(network::packet& packet) {
auto* ip_header = reinterpret_cast<network::ip::header*>(packet.payload + packet.tag(1));
auto* tcp_header = reinterpret_cast<network::tcp::header*>(packet.payload + packet.tag(2));
@ -67,7 +67,7 @@ uint16_t get_default_flags() {
return flags;
}
void prepare_packet(network::ethernet::packet& packet, size_t source, size_t target) {
void prepare_packet(network::packet& packet, size_t source, size_t target) {
packet.tag(2, packet.index);
// Set the TCP header
@ -82,7 +82,7 @@ void prepare_packet(network::ethernet::packet& packet, size_t source, size_t tar
packet.index += default_tcp_header_length;
}
size_t tcp_payload_len(const network::ethernet::packet& packet){
size_t tcp_payload_len(const network::packet& packet){
auto* ip_header = reinterpret_cast<const network::ip::header*>(packet.payload + packet.tag(1));
auto* tcp_header = reinterpret_cast<const network::tcp::header*>(packet.payload + packet.tag(2));
@ -105,7 +105,7 @@ network::tcp::layer::layer(network::ip::layer* parent) : parent(parent) {
local_port = 1023;
}
void network::tcp::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet) {
void network::tcp::layer::decode(network::interface_descriptor& interface, network::packet& packet) {
packet.tag(2, packet.index);
auto* ip_header = reinterpret_cast<network::ip::header*>(packet.payload + packet.tag(1));
@ -287,12 +287,12 @@ std::expected<size_t> network::tcp::layer::receive(char* buffer, network::socket
return payload_len;
}
std::expected<network::ethernet::packet> network::tcp::layer::user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor) {
std::expected<network::packet> network::tcp::layer::user_prepare_packet(char* buffer, network::socket& socket, const packet_descriptor* descriptor) {
auto& connection = socket.get_connection_data<tcp_connection>();
// Make sure stream sockets are connected
if(!connection.connected){
return std::make_unexpected<network::ethernet::packet>(std::ERROR_SOCKET_NOT_CONNECTED);
return std::make_unexpected<network::packet>(std::ERROR_SOCKET_NOT_CONNECTED);
}
auto target_ip = connection.server_address;
@ -322,7 +322,7 @@ std::expected<network::ethernet::packet> network::tcp::layer::user_prepare_packe
return packet;
}
std::expected<void> network::tcp::layer::finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::ethernet::packet& p) {
std::expected<void> network::tcp::layer::finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::packet& p) {
auto* tcp_header = reinterpret_cast<network::tcp::header*>(p.payload + p.tag(2));
auto source_flags = switch_endian_16(tcp_header->flags);
@ -862,7 +862,7 @@ std::expected<void> network::tcp::layer::disconnect(network::socket& sock) {
}
// This is used for raw answer
std::expected<network::ethernet::packet> network::tcp::layer::kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size) {
std::expected<network::packet> network::tcp::layer::kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size) {
// Ask the IP layer to craft a packet
network::ip::packet_descriptor desc{payload_size + default_tcp_header_length, target_ip, 0x06};
auto packet = parent->kernel_prepare_packet(interface, desc);
@ -875,7 +875,7 @@ std::expected<network::ethernet::packet> network::tcp::layer::kernel_prepare_pac
}
// This is used for TCP connection answers
std::expected<network::ethernet::packet> network::tcp::layer::kernel_prepare_packet(network::interface_descriptor& interface, tcp_connection& connection, size_t payload_size) {
std::expected<network::packet> network::tcp::layer::kernel_prepare_packet(network::interface_descriptor& interface, tcp_connection& connection, size_t payload_size) {
auto target_ip = connection.server_address;
auto local_port = connection.local_port;
auto server_port = connection.server_port;
@ -897,7 +897,7 @@ std::expected<network::ethernet::packet> network::tcp::layer::kernel_prepare_pac
}
// finalize without waiting for ACK
std::expected<void> network::tcp::layer::finalize_packet_direct(network::interface_descriptor& interface, network::ethernet::packet& p) {
std::expected<void> network::tcp::layer::finalize_packet_direct(network::interface_descriptor& interface, network::packet& p) {
auto* tcp_header = reinterpret_cast<network::tcp::header*>(p.payload + p.tag(2));
auto flags = switch_endian_16(tcp_header->flags);

14
kernel/src/net/udp_layer.cpp
View File

@ -18,7 +18,7 @@
namespace {
void compute_checksum(network::ethernet::packet& packet){
void compute_checksum(network::packet& packet){
auto* ip_header = reinterpret_cast<network::ip::header*>(packet.payload + packet.tag(1));
auto* udp_header = reinterpret_cast<network::udp::header*>(packet.payload + packet.tag(2));
@ -42,7 +42,7 @@ void compute_checksum(network::ethernet::packet& packet){
udp_header->checksum = switch_endian_16(network::checksum_finalize_nz(sum));
}
void prepare_packet(network::ethernet::packet& packet, size_t source, size_t target, size_t payload_size){
void prepare_packet(network::packet& packet, size_t source, size_t target, size_t payload_size){
packet.tag(2, packet.index);
// Set the UDP header
@ -65,7 +65,7 @@ network::udp::layer::layer(network::ip::layer* parent) : parent(parent) {
local_port = 1023;
}
void network::udp::layer::decode(network::interface_descriptor& interface, network::ethernet::packet& packet){
void network::udp::layer::decode(network::interface_descriptor& interface, network::packet& packet){
packet.tag(2, packet.index);
auto* udp_header = reinterpret_cast<header*>(packet.payload + packet.index);
@ -112,7 +112,7 @@ void network::udp::layer::decode(network::interface_descriptor& interface, netwo
}
}
std::expected<network::ethernet::packet> network::udp::layer::kernel_prepare_packet(network::interface_descriptor& interface, const kernel_packet_descriptor& descriptor){
std::expected<network::packet> network::udp::layer::kernel_prepare_packet(network::interface_descriptor& interface, const kernel_packet_descriptor& descriptor){
// Ask the IP layer to craft a packet
network::ip::packet_descriptor desc{sizeof(header) + descriptor.payload_size, descriptor.target_ip, 0x11};
auto packet = parent->kernel_prepare_packet(interface, desc);
@ -124,7 +124,7 @@ std::expected<network::ethernet::packet> network::udp::layer::kernel_prepare_pac
return packet;
}
std::expected<network::ethernet::packet> network::udp::layer::user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor){
std::expected<network::packet> network::udp::layer::user_prepare_packet(char* buffer, network::socket& sock, const packet_descriptor* descriptor){
auto& connection = sock.get_connection_data<udp_connection>();
auto ip = connection.server_address;
@ -142,7 +142,7 @@ std::expected<network::ethernet::packet> network::udp::layer::user_prepare_packe
return packet;
}
std::expected<network::ethernet::packet> network::udp::layer::user_prepare_packet(char* buffer, network::socket& sock, const network::udp::packet_descriptor* descriptor, network::inet_address* address){
std::expected<network::packet> network::udp::layer::user_prepare_packet(char* buffer, network::socket& sock, const network::udp::packet_descriptor* descriptor, network::inet_address* address){
auto& connection = sock.get_connection_data<udp_connection>();
auto ip = connection.server_address;
@ -160,7 +160,7 @@ std::expected<network::ethernet::packet> network::udp::layer::user_prepare_packe
return packet;
}
std::expected<void> network::udp::layer::finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p){
std::expected<void> network::udp::layer::finalize_packet(network::interface_descriptor& interface, network::packet& p){
p.index -= sizeof(header);
// Compute the checksum