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

Rename prepare_packet

Browse Source
This commit is contained in:
Baptiste Wicht 2016-09-17 20:33:36 +02:00
parent 2f0ee33ba9
commit 6caa59e5af
16 changed files with 49 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -22,8 +22,8 @@ static_assert(sizeof(header) == 12, "DNS flags must be 96 bits");
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
std::expected<network::ethernet::packet> prepare_packet_query(network::interface_descriptor& interface, network::ip::address target_ip, uint16_t source_port, uint16_t identification, size_t payload_size);
std::expected<network::ethernet::packet> prepare_packet_query(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, uint16_t source_port, uint16_t identification, size_t payload_size);
std::expected<network::ethernet::packet> kernel_prepare_packet_query(network::interface_descriptor& interface, network::ip::address target_ip, uint16_t source_port, uint16_t identification, size_t payload_size);
std::expected<network::ethernet::packet> user_prepare_packet_query(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, uint16_t source_port, uint16_t identification, size_t payload_size);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);

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

@ -26,8 +26,9 @@ void mac64_to_mac6(uint64_t input, char* mac);
void decode(network::interface_descriptor& interface, packet& packet);
std::expected<packet> prepare_packet(network::interface_descriptor& interface, size_t size, size_t destination, ether_type type);
std::expected<packet> prepare_packet(char* buffer, network::interface_descriptor& interface, size_t size, size_t destination, ether_type type);
std::expected<packet> kernel_prepare_packet(network::interface_descriptor& interface, size_t size, size_t destination, ether_type type);
std::expected<packet> user_prepare_packet(char* buffer, network::interface_descriptor& interface, size_t size, size_t destination, ether_type type);
std::expected<void> finalize_packet(network::interface_descriptor& interface, packet& p);

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

@ -24,8 +24,8 @@ static_assert(sizeof(echo_request_header) == sizeof(header::rest), "Invalid size
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
std::expected<network::ethernet::packet> prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t payload_size, type t, size_t code);
std::expected<network::ethernet::packet> prepare_packet(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, size_t payload_size, type t, size_t code);
std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t payload_size, type t, size_t code);
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, size_t payload_size, type t, size_t code);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);

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

@ -28,8 +28,9 @@ static_assert(sizeof(header) == 20, "The size of an IPv4 header must be 20 bytes
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
std::expected<network::ethernet::packet> prepare_packet(network::interface_descriptor& interface, size_t size, address& destination, size_t protocol);
std::expected<network::ethernet::packet> prepare_packet(char* buffer, network::interface_descriptor& interface, size_t size, address& destination, size_t protocol);
std::expected<network::ethernet::packet> kernel_prepare_packet(network::interface_descriptor& interface, size_t size, address& destination, size_t protocol);
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::interface_descriptor& interface, size_t size, address& destination, size_t protocol);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
} // end of ip namespace

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

@ -21,8 +21,8 @@ namespace tcp {
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
std::expected<network::ethernet::packet> 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> prepare_packet(char* buffer, network::socket& socket, size_t payload_size);
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> user_prepare_packet(char* buffer, network::socket& socket, size_t payload_size);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::socket& socket, network::ethernet::packet& p);

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

@ -27,8 +27,8 @@ struct header {
void decode(network::interface_descriptor& interface, network::ethernet::packet& packet);
std::expected<network::ethernet::packet> 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> prepare_packet(char* buffer, 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, network::ip::address target_ip, size_t source, size_t target, size_t payload_size);
std::expected<network::ethernet::packet> user_prepare_packet(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size);
std::expected<void> finalize_packet(network::interface_descriptor& interface, network::ethernet::packet& p);
} // end of upd namespace

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

@ -31,7 +31,7 @@ void network::alpha(){
size_t payload_size = labels + characters + 1 + 2 * 2;
// Ask the DNS layer to craft a packet
auto packet = network::dns::prepare_packet_query(interface, target_ip, 3456, 0x666, payload_size);
auto packet = network::dns::kernel_prepare_packet_query(interface, target_ip, 3456, 0x666, payload_size);
if(packet){
auto* payload = reinterpret_cast<char*>(packet->payload + packet->index);

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

@ -33,7 +33,7 @@ std::vector<cache_entry> cache;
std::expected<void> arp_request(network::interface_descriptor& interface, network::ip::address ip){
// Ask the ethernet layer to craft a packet
auto packet = network::ethernet::prepare_packet(interface, sizeof(network::arp::header), 0xFFFFFFFFFFFF, network::ethernet::ether_type::ARP);
auto packet = network::ethernet::kernel_prepare_packet(interface, sizeof(network::arp::header), 0xFFFFFFFFFFFF, network::ethernet::ether_type::ARP);
if(packet){
auto* arp_request_header = reinterpret_cast<network::arp::header*>(packet->payload + packet->index);

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

@ -121,7 +121,7 @@ void network::arp::decode(network::interface_descriptor& interface, network::eth
logging::logf(logging::log_level::TRACE, "arp: Reply to Request for own IP\n");
// Ask the ethernet layer to craft a packet
auto packet = network::ethernet::prepare_packet(interface, sizeof(header), source_hw, ethernet::ether_type::ARP);
auto packet = network::ethernet::kernel_prepare_packet(interface, sizeof(header), source_hw, ethernet::ether_type::ARP);
if(packet){
auto* arp_reply_header = reinterpret_cast<header*>(packet->payload + packet->index);

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

@ -192,9 +192,9 @@ void network::dns::decode(network::interface_descriptor& /*interface*/, network:
network::propagate_packet(packet, network::socket_protocol::DNS);
}
std::expected<network::ethernet::packet> network::dns::prepare_packet_query(network::interface_descriptor& interface, network::ip::address target_ip, uint16_t source_port, uint16_t identification, size_t payload_size) {
std::expected<network::ethernet::packet> network::dns::kernel_prepare_packet_query(network::interface_descriptor& interface, network::ip::address target_ip, uint16_t source_port, uint16_t identification, size_t payload_size) {
// Ask the UDP layer to craft a packet
auto packet = network::udp::prepare_packet(interface, target_ip, source_port, 53, sizeof(header) + payload_size);
auto packet = network::udp::kernel_prepare_packet(interface, target_ip, source_port, 53, sizeof(header) + payload_size);
if (packet) {
::prepare_packet_query(*packet, identification);
@ -203,9 +203,9 @@ std::expected<network::ethernet::packet> network::dns::prepare_packet_query(netw
return packet;
}
std::expected<network::ethernet::packet> network::dns::prepare_packet_query(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, uint16_t source_port, uint16_t identification, size_t payload_size) {
std::expected<network::ethernet::packet> network::dns::user_prepare_packet_query(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, uint16_t source_port, uint16_t identification, size_t payload_size) {
// Ask the UDP layer to craft a packet
auto packet = network::udp::prepare_packet(buffer, interface, target_ip, source_port, 53, sizeof(header) + payload_size);
auto packet = network::udp::user_prepare_packet(buffer, interface, target_ip, source_port, 53, sizeof(header) + payload_size);
if (packet) {
::prepare_packet_query(*packet, identification);

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

@ -123,7 +123,7 @@ void network::ethernet::decode(network::interface_descriptor& interface, packet&
logging::logf(logging::log_level::TRACE, "ethernet: Finished decoding packet\n");
}
std::expected<network::ethernet::packet> network::ethernet::prepare_packet(network::interface_descriptor& interface, size_t size, size_t destination, ether_type type){
std::expected<network::ethernet::packet> network::ethernet::kernel_prepare_packet(network::interface_descriptor& interface, size_t size, size_t destination, ether_type type){
auto total_size = size + sizeof(header);
network::ethernet::packet p(new char[total_size], total_size);
@ -133,7 +133,7 @@ std::expected<network::ethernet::packet> network::ethernet::prepare_packet(netwo
return p;
}
std::expected<network::ethernet::packet> network::ethernet::prepare_packet(char* buffer, network::interface_descriptor& interface, size_t size, size_t destination, ether_type type){
std::expected<network::ethernet::packet> network::ethernet::user_prepare_packet(char* buffer, network::interface_descriptor& interface, size_t size, size_t destination, ether_type type){
auto total_size = size + sizeof(header);
network::ethernet::packet p(buffer, total_size);

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

@ -81,7 +81,7 @@ void network::icmp::decode(network::interface_descriptor& interface, network::et
if(target_ip == interface.ip_address){
logging::logf(logging::log_level::TRACE, "icmp: Reply to Echo Request for own IP\n");
auto reply_packet = network::icmp::prepare_packet(interface, source_ip, 0x0, type::ECHO_REPLY, 0x0);
auto reply_packet = network::icmp::kernel_prepare_packet(interface, source_ip, 0x0, type::ECHO_REPLY, 0x0);
if(reply_packet){
auto* command_header = reinterpret_cast<echo_request_header*>(packet.payload + command_index);
@ -114,9 +114,9 @@ void network::icmp::decode(network::interface_descriptor& interface, network::et
network::propagate_packet(packet, network::socket_protocol::ICMP);
}
std::expected<network::ethernet::packet> network::icmp::prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t payload_size, type t, size_t code){
std::expected<network::ethernet::packet> network::icmp::kernel_prepare_packet(network::interface_descriptor& interface, network::ip::address target_ip, size_t payload_size, type t, size_t code){
// Ask the IP layer to craft a packet
auto packet = network::ip::prepare_packet(interface, sizeof(header) + payload_size, target_ip, 0x01);
auto packet = network::ip::kernel_prepare_packet(interface, sizeof(header) + payload_size, target_ip, 0x01);
if(packet){
::prepare_packet(*packet, t, code);
@ -125,9 +125,9 @@ std::expected<network::ethernet::packet> network::icmp::prepare_packet(network::
return packet;
}
std::expected<network::ethernet::packet> network::icmp::prepare_packet(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, size_t payload_size, type t, size_t code){
std::expected<network::ethernet::packet> network::icmp::user_prepare_packet(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, size_t payload_size, type t, size_t code){
// Ask the IP layer to craft a packet
auto packet = network::ip::prepare_packet(buffer, interface, sizeof(header) + payload_size, target_ip, 0x01);
auto packet = network::ip::user_prepare_packet(buffer, interface, sizeof(header) + payload_size, target_ip, 0x01);
if(packet){
::prepare_packet(*packet, t, code);
@ -162,7 +162,7 @@ void network::icmp::ping(network::interface_descriptor& interface, network::ip::
logging::logf(logging::log_level::TRACE, "icmp: Target MAC Address: %h\n", *target_mac);
// Ask the ICMP layer to craft a packet
auto packet = network::icmp::prepare_packet(interface, target_ip, 0, type::ECHO_REQUEST, 0);
auto packet = network::icmp::kernel_prepare_packet(interface, target_ip, 0, type::ECHO_REQUEST, 0);
if(packet){
// Set the Command header

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

@ -152,7 +152,7 @@ void network::ip::decode(network::interface_descriptor& interface, network::ethe
}
}
std::expected<network::ethernet::packet> network::ip::prepare_packet(network::interface_descriptor& interface, size_t size, address& target_ip, size_t protocol){
std::expected<network::ethernet::packet> network::ip::kernel_prepare_packet(network::interface_descriptor& interface, size_t size, address& target_ip, size_t protocol){
auto target_mac = get_target_mac(interface, target_ip);
if(!target_mac){
@ -160,7 +160,7 @@ std::expected<network::ethernet::packet> network::ip::prepare_packet(network::in
}
// Ask the ethernet layer to craft a packet
auto packet = network::ethernet::prepare_packet(interface, size + sizeof(header), *target_mac, ethernet::ether_type::IPV4);
auto packet = network::ethernet::kernel_prepare_packet(interface, size + sizeof(header), *target_mac, ethernet::ether_type::IPV4);
if(packet){
::prepare_packet(*packet, interface, size, target_ip, protocol);
@ -169,7 +169,7 @@ std::expected<network::ethernet::packet> network::ip::prepare_packet(network::in
return packet;
}
std::expected<network::ethernet::packet> network::ip::prepare_packet(char* buffer, network::interface_descriptor& interface, size_t size, address& target_ip, size_t protocol){
std::expected<network::ethernet::packet> network::ip::user_prepare_packet(char* buffer, network::interface_descriptor& interface, size_t size, address& target_ip, size_t protocol){
auto target_mac = get_target_mac(interface, target_ip);
if(!target_mac){
@ -177,7 +177,7 @@ std::expected<network::ethernet::packet> network::ip::prepare_packet(char* buffe
}
// Ask the ethernet layer to craft a packet
auto packet = network::ethernet::prepare_packet(buffer, interface, size + sizeof(header), *target_mac, ethernet::ether_type::IPV4);
auto packet = network::ethernet::user_prepare_packet(buffer, interface, size + sizeof(header), *target_mac, ethernet::ether_type::IPV4);
if(packet){
::prepare_packet(*packet, interface, size, target_ip, protocol);

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

@ -301,14 +301,14 @@ std::tuple<size_t, size_t> network::prepare_packet(socket_fd_t socket_fd, void*
case network::socket_protocol::ICMP: {
auto descriptor = static_cast<network::icmp::packet_descriptor*>(desc);
auto& interface = select_interface(descriptor->target_ip);
auto packet = network::icmp::prepare_packet(buffer, interface, descriptor->target_ip, descriptor->payload_size, descriptor->type, descriptor->code);
auto packet = network::icmp::user_prepare_packet(buffer, interface, descriptor->target_ip, descriptor->payload_size, descriptor->type, descriptor->code);
return return_from_packet(packet);
}
case network::socket_protocol::TCP: {
auto descriptor = static_cast<network::tcp::packet_descriptor*>(desc);
auto packet = network::tcp::prepare_packet(buffer, socket, descriptor->payload_size);
auto packet = network::tcp::user_prepare_packet(buffer, socket, descriptor->payload_size);
return return_from_packet(packet);
}
@ -319,7 +319,7 @@ std::tuple<size_t, size_t> network::prepare_packet(socket_fd_t socket_fd, void*
if(descriptor->query){
auto source_port = get_port(descriptor->source_port);
auto packet = network::dns::prepare_packet_query(buffer, interface, descriptor->target_ip, source_port, descriptor->identification, descriptor->payload_size);
auto packet = network::dns::user_prepare_packet_query(buffer, interface, descriptor->target_ip, source_port, descriptor->identification, descriptor->payload_size);
return return_from_packet(packet);
} else {

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

@ -232,7 +232,7 @@ void network::tcp::decode(network::interface_descriptor& interface, network::eth
// Acknowledge if necessary
if (*flag_psh(&flags)) {
auto p = tcp::prepare_packet(interface, switch_endian_32(ip_header->source_ip), target_port, source_port, 0);
auto p = tcp::kernel_prepare_packet(interface, switch_endian_32(ip_header->source_ip), target_port, source_port, 0);
if (!p) {
logging::logf(logging::log_level::ERROR, "tcp: Impossible to prepare TCP packet for ACK\n");
@ -252,9 +252,9 @@ void network::tcp::decode(network::interface_descriptor& interface, network::eth
}
}
std::expected<network::ethernet::packet> network::tcp::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> network::tcp::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
auto packet = network::ip::prepare_packet(interface, sizeof(header) + payload_size, target_ip, 0x06);
auto packet = network::ip::kernel_prepare_packet(interface, sizeof(header) + payload_size, target_ip, 0x06);
if (packet) {
::prepare_packet(*packet, source, target);
@ -263,7 +263,7 @@ std::expected<network::ethernet::packet> network::tcp::prepare_packet(network::i
return packet;
}
std::expected<network::ethernet::packet> network::tcp::prepare_packet(char* buffer, network::socket& socket, size_t payload_size) {
std::expected<network::ethernet::packet> network::tcp::user_prepare_packet(char* buffer, network::socket& socket, size_t payload_size) {
auto& connection = socket.get_data<tcp_connection>();
// Make sure stream sockets are connected
@ -275,7 +275,7 @@ std::expected<network::ethernet::packet> network::tcp::prepare_packet(char* buff
auto& interface = network::select_interface(target_ip);
// Ask the IP layer to craft a packet
auto packet = network::ip::prepare_packet(buffer, interface, sizeof(header) + payload_size, target_ip, 0x06);
auto packet = network::ip::user_prepare_packet(buffer, interface, sizeof(header) + payload_size, target_ip, 0x06);
if (packet) {
auto source = connection.local_port;
@ -414,7 +414,7 @@ std::expected<void> network::tcp::connect(network::socket& sock, network::interf
auto target_ip = connection.server_address;
auto packet = tcp::prepare_packet(interface, target_ip, local_port, server_port, 0);
auto packet = tcp::kernel_prepare_packet(interface, target_ip, local_port, server_port, 0);
if (!packet) {
return std::make_unexpected<void>(packet.error());
@ -469,7 +469,7 @@ std::expected<void> network::tcp::connect(network::socket& sock, network::interf
// At this point we have received the SYN/ACK, only remains to ACK
{
auto packet = tcp::prepare_packet(interface, target_ip, connection.local_port, connection.server_port, 0);
auto packet = tcp::kernel_prepare_packet(interface, target_ip, connection.local_port, connection.server_port, 0);
if (!packet) {
return std::make_unexpected<void>(packet.error());
@ -508,7 +508,7 @@ std::expected<void> network::tcp::disconnect(network::socket& sock) {
auto& interface = network::select_interface(target_ip);
auto packet = tcp::prepare_packet(interface, target_ip, source, target, 0);
auto packet = tcp::kernel_prepare_packet(interface, target_ip, source, target, 0);
if (!packet) {
return std::make_unexpected<void>(packet.error());
@ -576,7 +576,7 @@ std::expected<void> network::tcp::disconnect(network::socket& sock) {
// At this point we have received the FIN/ACK, only remains to ACK
{
auto packet = tcp::prepare_packet(interface, target_ip, source, target, 0);
auto packet = tcp::kernel_prepare_packet(interface, target_ip, source, target, 0);
if (!packet) {
return std::make_unexpected<void>(packet.error());

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

@ -75,9 +75,9 @@ void network::udp::decode(network::interface_descriptor& interface, network::eth
}
}
std::expected<network::ethernet::packet> network::udp::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> network::udp::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
auto packet = network::ip::prepare_packet(interface, sizeof(header) + payload_size, target_ip, 0x11);
auto packet = network::ip::kernel_prepare_packet(interface, sizeof(header) + payload_size, target_ip, 0x11);
if(packet){
::prepare_packet(*packet, source, target, payload_size);
@ -86,9 +86,9 @@ std::expected<network::ethernet::packet> network::udp::prepare_packet(network::i
return packet;
}
std::expected<network::ethernet::packet> network::udp::prepare_packet(char* buffer, network::interface_descriptor& interface, network::ip::address target_ip, size_t source, size_t target, size_t payload_size){
std::expected<network::ethernet::packet> network::udp::user_prepare_packet(char* buffer, 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
auto packet = network::ip::prepare_packet(buffer, interface, sizeof(header) + payload_size, target_ip, 0x11);
auto packet = network::ip::user_prepare_packet(buffer, interface, sizeof(header) + payload_size, target_ip, 0x11);
if(packet){
::prepare_packet(*packet, source, target, payload_size);