2020-01-18 08:38:21 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
|
|
|
* list of conditions and the following disclaimer.
|
|
|
|
*
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
|
|
* and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2019-06-07 09:43:58 +00:00
|
|
|
#include <Kernel/Lock.h>
|
|
|
|
#include <Kernel/Net/ARP.h>
|
|
|
|
#include <Kernel/Net/EtherType.h>
|
2019-04-02 17:54:38 +00:00
|
|
|
#include <Kernel/Net/EthernetFrameHeader.h>
|
|
|
|
#include <Kernel/Net/ICMP.h>
|
|
|
|
#include <Kernel/Net/IPv4.h>
|
|
|
|
#include <Kernel/Net/IPv4Socket.h>
|
2019-06-07 09:43:58 +00:00
|
|
|
#include <Kernel/Net/LoopbackAdapter.h>
|
2019-08-28 11:53:01 +00:00
|
|
|
#include <Kernel/Net/Routing.h>
|
2019-06-07 09:43:58 +00:00
|
|
|
#include <Kernel/Net/TCP.h>
|
2019-04-02 17:54:38 +00:00
|
|
|
#include <Kernel/Net/TCPSocket.h>
|
2019-06-07 09:43:58 +00:00
|
|
|
#include <Kernel/Net/UDP.h>
|
2019-04-02 17:54:38 +00:00
|
|
|
#include <Kernel/Net/UDPSocket.h>
|
2019-03-11 11:43:45 +00:00
|
|
|
#include <Kernel/Process.h>
|
2019-03-11 22:21:38 +00:00
|
|
|
|
2019-08-28 11:53:01 +00:00
|
|
|
//#define NETWORK_TASK_DEBUG
|
2019-03-12 03:11:20 +00:00
|
|
|
//#define ETHERNET_DEBUG
|
2019-08-06 13:40:38 +00:00
|
|
|
//#define ETHERNET_VERY_DEBUG
|
2019-08-28 11:58:01 +00:00
|
|
|
//#define ARP_DEBUG
|
2019-08-04 08:04:06 +00:00
|
|
|
//#define IPV4_DEBUG
|
2019-03-13 13:22:27 +00:00
|
|
|
//#define ICMP_DEBUG
|
2019-08-04 08:04:06 +00:00
|
|
|
//#define UDP_DEBUG
|
|
|
|
//#define TCP_DEBUG
|
2019-03-12 03:11:20 +00:00
|
|
|
|
2019-08-09 08:42:01 +00:00
|
|
|
static void handle_arp(const EthernetFrameHeader&, size_t frame_size);
|
|
|
|
static void handle_ipv4(const EthernetFrameHeader&, size_t frame_size);
|
|
|
|
static void handle_icmp(const EthernetFrameHeader&, const IPv4Packet&);
|
|
|
|
static void handle_udp(const IPv4Packet&);
|
|
|
|
static void handle_tcp(const IPv4Packet&);
|
2019-03-11 11:43:45 +00:00
|
|
|
|
|
|
|
void NetworkTask_main()
|
|
|
|
{
|
2019-12-01 15:47:49 +00:00
|
|
|
WaitQueue packet_wait_queue;
|
2019-08-28 11:53:01 +00:00
|
|
|
u8 octet = 15;
|
|
|
|
int pending_packets = 0;
|
2019-12-01 15:47:49 +00:00
|
|
|
NetworkAdapter::for_each([&](auto& adapter) {
|
2019-08-28 11:53:01 +00:00
|
|
|
if (String(adapter.class_name()) == "LoopbackAdapter") {
|
|
|
|
adapter.set_ipv4_address({ 127, 0, 0, 1 });
|
|
|
|
adapter.set_ipv4_netmask({ 255, 0, 0, 0 });
|
|
|
|
adapter.set_ipv4_gateway({ 0, 0, 0, 0 });
|
|
|
|
} else {
|
|
|
|
adapter.set_ipv4_address({ 10, 0, 2, octet++ });
|
|
|
|
adapter.set_ipv4_netmask({ 255, 255, 255, 0 });
|
|
|
|
adapter.set_ipv4_gateway({ 10, 0, 2, 2 });
|
|
|
|
}
|
2019-04-02 13:46:44 +00:00
|
|
|
|
2019-08-28 11:53:01 +00:00
|
|
|
kprintf("NetworkTask: %s network adapter found: hw=%s address=%s netmask=%s gateway=%s\n",
|
|
|
|
adapter.class_name(),
|
|
|
|
adapter.mac_address().to_string().characters(),
|
|
|
|
adapter.ipv4_address().to_string().characters(),
|
|
|
|
adapter.ipv4_netmask().to_string().characters(),
|
|
|
|
adapter.ipv4_gateway().to_string().characters());
|
2019-05-17 22:22:08 +00:00
|
|
|
|
2019-12-01 15:47:49 +00:00
|
|
|
adapter.on_receive = [&]() {
|
2019-08-28 11:53:01 +00:00
|
|
|
pending_packets++;
|
2019-12-01 15:47:49 +00:00
|
|
|
packet_wait_queue.wake_all();
|
2019-08-28 12:14:38 +00:00
|
|
|
};
|
2019-08-28 11:53:01 +00:00
|
|
|
});
|
2019-03-11 11:43:45 +00:00
|
|
|
|
2019-12-14 10:07:37 +00:00
|
|
|
auto dequeue_packet = [&pending_packets](u8* buffer, size_t buffer_size) -> size_t {
|
2019-12-01 15:47:49 +00:00
|
|
|
if (pending_packets == 0)
|
2019-12-14 10:07:37 +00:00
|
|
|
return 0;
|
|
|
|
size_t packet_size = 0;
|
|
|
|
NetworkAdapter::for_each([&](auto& adapter) {
|
|
|
|
if (packet_size || !adapter.has_queued_packets())
|
2019-08-28 11:53:01 +00:00
|
|
|
return;
|
2019-12-14 10:07:37 +00:00
|
|
|
packet_size = adapter.dequeue_packet(buffer, buffer_size);
|
2019-08-28 11:53:01 +00:00
|
|
|
pending_packets--;
|
|
|
|
#ifdef NETWORK_TASK_DEBUG
|
2019-12-28 00:19:07 +00:00
|
|
|
kprintf("NetworkTask: Dequeued packet from %s (%d bytes)\n", adapter.name().characters(), packet_size);
|
2019-08-28 11:53:01 +00:00
|
|
|
#endif
|
|
|
|
});
|
2019-12-14 10:07:37 +00:00
|
|
|
return packet_size;
|
2019-04-02 13:46:44 +00:00
|
|
|
};
|
|
|
|
|
2019-12-27 23:07:56 +00:00
|
|
|
size_t buffer_size = 64 * KB;
|
|
|
|
auto buffer_region = MM.allocate_kernel_region(buffer_size, "Kernel Packet Buffer", Region::Access::Read | Region::Access::Write, false, true);
|
|
|
|
auto buffer = (u8*)buffer_region->vaddr().get();
|
|
|
|
|
2019-03-11 11:43:45 +00:00
|
|
|
kprintf("NetworkTask: Enter main loop.\n");
|
|
|
|
for (;;) {
|
2019-12-27 23:07:56 +00:00
|
|
|
size_t packet_size = dequeue_packet(buffer, buffer_size);
|
2019-12-14 10:07:37 +00:00
|
|
|
if (!packet_size) {
|
2019-12-01 15:47:49 +00:00
|
|
|
current->wait_on(packet_wait_queue);
|
2019-03-11 11:43:45 +00:00
|
|
|
continue;
|
|
|
|
}
|
2019-12-14 10:07:37 +00:00
|
|
|
if (packet_size < sizeof(EthernetFrameHeader)) {
|
|
|
|
kprintf("NetworkTask: Packet is too small to be an Ethernet packet! (%zu)\n", packet_size);
|
2019-03-11 11:43:45 +00:00
|
|
|
continue;
|
|
|
|
}
|
2019-12-27 23:07:56 +00:00
|
|
|
auto& eth = *(const EthernetFrameHeader*)buffer;
|
2019-03-12 03:11:20 +00:00
|
|
|
#ifdef ETHERNET_DEBUG
|
2019-03-11 22:21:38 +00:00
|
|
|
kprintf("NetworkTask: From %s to %s, ether_type=%w, packet_length=%u\n",
|
|
|
|
eth.source().to_string().characters(),
|
|
|
|
eth.destination().to_string().characters(),
|
|
|
|
eth.ether_type(),
|
2019-12-14 10:07:37 +00:00
|
|
|
packet_size);
|
2019-03-12 03:11:20 +00:00
|
|
|
#endif
|
2019-03-11 22:21:38 +00:00
|
|
|
|
2019-08-06 13:40:38 +00:00
|
|
|
#ifdef ETHERNET_VERY_DEBUG
|
2019-12-14 10:07:37 +00:00
|
|
|
for (size_t i = 0; i < packet_size; i++) {
|
2019-12-27 23:07:56 +00:00
|
|
|
kprintf("%b", buffer[i]);
|
2019-08-06 13:40:38 +00:00
|
|
|
|
|
|
|
switch (i % 16) {
|
|
|
|
case 7:
|
|
|
|
kprintf(" ");
|
|
|
|
break;
|
|
|
|
case 15:
|
|
|
|
kprintf("\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
kprintf(" ");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
kprintf("\n");
|
|
|
|
#endif
|
|
|
|
|
2019-03-11 22:21:38 +00:00
|
|
|
switch (eth.ether_type()) {
|
|
|
|
case EtherType::ARP:
|
2019-12-14 10:07:37 +00:00
|
|
|
handle_arp(eth, packet_size);
|
2019-03-11 22:21:38 +00:00
|
|
|
break;
|
|
|
|
case EtherType::IPv4:
|
2019-12-14 10:07:37 +00:00
|
|
|
handle_ipv4(eth, packet_size);
|
2019-03-11 22:21:38 +00:00
|
|
|
break;
|
2019-08-28 00:53:12 +00:00
|
|
|
case EtherType::IPv6:
|
|
|
|
// ignore
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
kprintf("NetworkTask: Unknown ethernet type %#04x\n", eth.ether_type());
|
2019-03-11 22:21:38 +00:00
|
|
|
}
|
2019-03-11 11:43:45 +00:00
|
|
|
}
|
|
|
|
}
|
2019-03-11 22:21:38 +00:00
|
|
|
|
2019-08-09 08:42:01 +00:00
|
|
|
void handle_arp(const EthernetFrameHeader& eth, size_t frame_size)
|
2019-03-11 22:21:38 +00:00
|
|
|
{
|
2019-08-09 08:42:01 +00:00
|
|
|
constexpr size_t minimum_arp_frame_size = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
|
2019-03-11 22:21:38 +00:00
|
|
|
if (frame_size < minimum_arp_frame_size) {
|
|
|
|
kprintf("handle_arp: Frame too small (%d, need %d)\n", frame_size, minimum_arp_frame_size);
|
|
|
|
return;
|
|
|
|
}
|
2019-03-11 23:56:33 +00:00
|
|
|
auto& packet = *static_cast<const ARPPacket*>(eth.payload());
|
2019-03-11 23:01:07 +00:00
|
|
|
if (packet.hardware_type() != 1 || packet.hardware_address_length() != sizeof(MACAddress)) {
|
|
|
|
kprintf("handle_arp: Hardware type not ethernet (%w, len=%u)\n",
|
|
|
|
packet.hardware_type(),
|
2019-06-07 09:43:58 +00:00
|
|
|
packet.hardware_address_length());
|
2019-03-11 22:21:38 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-03-11 23:01:07 +00:00
|
|
|
if (packet.protocol_type() != EtherType::IPv4 || packet.protocol_address_length() != sizeof(IPv4Address)) {
|
|
|
|
kprintf("handle_arp: Protocol type not IPv4 (%w, len=%u)\n",
|
|
|
|
packet.hardware_type(),
|
2019-06-07 09:43:58 +00:00
|
|
|
packet.protocol_address_length());
|
2019-03-11 22:21:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef ARP_DEBUG
|
|
|
|
kprintf("handle_arp: operation=%w, sender=%s/%s, target=%s/%s\n",
|
2019-03-11 23:01:07 +00:00
|
|
|
packet.operation(),
|
|
|
|
packet.sender_hardware_address().to_string().characters(),
|
|
|
|
packet.sender_protocol_address().to_string().characters(),
|
|
|
|
packet.target_hardware_address().to_string().characters(),
|
2019-06-07 09:43:58 +00:00
|
|
|
packet.target_protocol_address().to_string().characters());
|
2019-03-11 22:21:38 +00:00
|
|
|
#endif
|
|
|
|
|
2019-09-08 07:26:21 +00:00
|
|
|
if (!packet.sender_hardware_address().is_zero() && !packet.sender_protocol_address().is_zero()) {
|
|
|
|
// Someone has this IPv4 address. I guess we can try to remember that.
|
|
|
|
// FIXME: Protect against ARP spamming.
|
|
|
|
// FIXME: Support static ARP table entries.
|
|
|
|
LOCKER(arp_table().lock());
|
|
|
|
arp_table().resource().set(packet.sender_protocol_address(), packet.sender_hardware_address());
|
|
|
|
|
|
|
|
kprintf("ARP table (%d entries):\n", arp_table().resource().size());
|
|
|
|
for (auto& it : arp_table().resource()) {
|
|
|
|
kprintf("%s :: %s\n", it.value.to_string().characters(), it.key.to_string().characters());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-12 00:30:49 +00:00
|
|
|
if (packet.operation() == ARPOperation::Request) {
|
2019-03-11 22:21:38 +00:00
|
|
|
// Who has this IP address?
|
2019-08-09 02:34:32 +00:00
|
|
|
if (auto adapter = NetworkAdapter::from_ipv4_address(packet.target_protocol_address())) {
|
2019-03-11 22:21:38 +00:00
|
|
|
// We do!
|
2019-03-11 23:01:07 +00:00
|
|
|
kprintf("handle_arp: Responding to ARP request for my IPv4 address (%s)\n",
|
2019-06-07 09:43:58 +00:00
|
|
|
adapter->ipv4_address().to_string().characters());
|
2019-03-11 22:21:38 +00:00
|
|
|
ARPPacket response;
|
2019-03-12 00:30:49 +00:00
|
|
|
response.set_operation(ARPOperation::Response);
|
2019-03-11 23:01:07 +00:00
|
|
|
response.set_target_hardware_address(packet.sender_hardware_address());
|
|
|
|
response.set_target_protocol_address(packet.sender_protocol_address());
|
2019-03-12 12:30:36 +00:00
|
|
|
response.set_sender_hardware_address(adapter->mac_address());
|
|
|
|
response.set_sender_protocol_address(adapter->ipv4_address());
|
2019-03-11 22:21:38 +00:00
|
|
|
|
2019-03-12 12:30:36 +00:00
|
|
|
adapter->send(packet.sender_hardware_address(), response);
|
2019-03-11 22:21:38 +00:00
|
|
|
}
|
2019-03-11 23:56:33 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-03-11 22:21:38 +00:00
|
|
|
}
|
|
|
|
|
2019-08-09 08:42:01 +00:00
|
|
|
void handle_ipv4(const EthernetFrameHeader& eth, size_t frame_size)
|
2019-03-11 22:21:38 +00:00
|
|
|
{
|
2019-08-09 08:42:01 +00:00
|
|
|
constexpr size_t minimum_ipv4_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet);
|
2019-03-12 03:11:20 +00:00
|
|
|
if (frame_size < minimum_ipv4_frame_size) {
|
|
|
|
kprintf("handle_ipv4: Frame too small (%d, need %d)\n", frame_size, minimum_ipv4_frame_size);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
auto& packet = *static_cast<const IPv4Packet*>(eth.payload());
|
2019-03-11 22:21:38 +00:00
|
|
|
|
2019-08-09 07:36:06 +00:00
|
|
|
if (packet.length() < sizeof(IPv4Packet)) {
|
|
|
|
kprintf("handle_ipv4: IPv4 packet too short (%u, need %u)\n", packet.length(), sizeof(IPv4Packet));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t actual_ipv4_packet_length = frame_size - sizeof(EthernetFrameHeader);
|
|
|
|
if (packet.length() > actual_ipv4_packet_length) {
|
|
|
|
kprintf("handle_ipv4: IPv4 packet claims to be longer than it is (%u, actually %zu)\n", packet.length(), actual_ipv4_packet_length);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-12 03:11:20 +00:00
|
|
|
#ifdef IPV4_DEBUG
|
|
|
|
kprintf("handle_ipv4: source=%s, target=%s\n",
|
|
|
|
packet.source().to_string().characters(),
|
2019-06-07 09:43:58 +00:00
|
|
|
packet.destination().to_string().characters());
|
2019-03-12 03:11:20 +00:00
|
|
|
#endif
|
|
|
|
|
2019-03-12 11:43:30 +00:00
|
|
|
switch ((IPv4Protocol)packet.protocol()) {
|
2019-03-12 03:11:20 +00:00
|
|
|
case IPv4Protocol::ICMP:
|
2019-08-09 08:42:01 +00:00
|
|
|
return handle_icmp(eth, packet);
|
2019-03-13 13:22:27 +00:00
|
|
|
case IPv4Protocol::UDP:
|
2019-08-09 08:42:01 +00:00
|
|
|
return handle_udp(packet);
|
2019-03-13 16:17:07 +00:00
|
|
|
case IPv4Protocol::TCP:
|
2019-08-09 08:42:01 +00:00
|
|
|
return handle_tcp(packet);
|
2019-03-12 03:11:20 +00:00
|
|
|
default:
|
|
|
|
kprintf("handle_ipv4: Unhandled protocol %u\n", packet.protocol());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-09 08:42:01 +00:00
|
|
|
void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet)
|
2019-03-12 03:11:20 +00:00
|
|
|
{
|
|
|
|
auto& icmp_header = *static_cast<const ICMPHeader*>(ipv4_packet.payload());
|
2019-03-12 10:44:38 +00:00
|
|
|
#ifdef ICMP_DEBUG
|
2019-03-13 13:22:27 +00:00
|
|
|
kprintf("handle_icmp: source=%s, destination=%s, type=%b, code=%b\n",
|
2019-03-12 10:44:38 +00:00
|
|
|
ipv4_packet.source().to_string().characters(),
|
|
|
|
ipv4_packet.destination().to_string().characters(),
|
|
|
|
icmp_header.type(),
|
2019-06-07 09:43:58 +00:00
|
|
|
icmp_header.code());
|
2019-03-12 10:44:38 +00:00
|
|
|
#endif
|
2019-03-12 11:43:30 +00:00
|
|
|
|
2019-03-12 16:27:07 +00:00
|
|
|
{
|
|
|
|
LOCKER(IPv4Socket::all_sockets().lock());
|
2019-06-21 16:37:47 +00:00
|
|
|
for (RefPtr<IPv4Socket> socket : IPv4Socket::all_sockets().resource()) {
|
2019-03-12 16:27:07 +00:00
|
|
|
LOCKER(socket->lock());
|
|
|
|
if (socket->protocol() != (unsigned)IPv4Protocol::ICMP)
|
|
|
|
continue;
|
2019-08-04 19:07:50 +00:00
|
|
|
socket->did_receive(ipv4_packet.source(), 0, KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
|
2019-03-12 16:27:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-09 02:34:32 +00:00
|
|
|
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
|
2019-03-12 12:30:36 +00:00
|
|
|
if (!adapter)
|
2019-03-12 11:43:30 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (icmp_header.type() == ICMPType::EchoRequest) {
|
|
|
|
auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header);
|
|
|
|
kprintf("handle_icmp: EchoRequest from %s: id=%u, seq=%u\n",
|
2019-06-07 09:43:58 +00:00
|
|
|
ipv4_packet.source().to_string().characters(),
|
2019-07-03 19:17:35 +00:00
|
|
|
(u16)request.identifier,
|
|
|
|
(u16)request.sequence_number);
|
2019-03-12 11:43:30 +00:00
|
|
|
size_t icmp_packet_size = ipv4_packet.payload_size();
|
|
|
|
auto buffer = ByteBuffer::create_zeroed(icmp_packet_size);
|
2019-09-30 06:57:01 +00:00
|
|
|
auto& response = *(ICMPEchoPacket*)buffer.data();
|
2019-03-12 11:43:30 +00:00
|
|
|
response.header.set_type(ICMPType::EchoReply);
|
|
|
|
response.header.set_code(0);
|
|
|
|
response.identifier = request.identifier;
|
|
|
|
response.sequence_number = request.sequence_number;
|
|
|
|
if (size_t icmp_payload_size = icmp_packet_size - sizeof(ICMPEchoPacket))
|
|
|
|
memcpy(response.payload(), request.payload(), icmp_payload_size);
|
|
|
|
response.header.set_checksum(internet_checksum(&response, icmp_packet_size));
|
2019-09-19 19:40:06 +00:00
|
|
|
// FIXME: What is the right TTL value here? Is 64 ok? Should we use the same TTL as the echo request?
|
|
|
|
adapter->send_ipv4(eth.source(), ipv4_packet.source(), IPv4Protocol::ICMP, buffer.data(), buffer.size(), 64);
|
2019-03-12 03:11:20 +00:00
|
|
|
}
|
2019-03-11 22:21:38 +00:00
|
|
|
}
|
2019-03-13 13:22:27 +00:00
|
|
|
|
2019-08-09 08:42:01 +00:00
|
|
|
void handle_udp(const IPv4Packet& ipv4_packet)
|
2019-03-13 13:22:27 +00:00
|
|
|
{
|
2019-08-09 08:42:01 +00:00
|
|
|
if (ipv4_packet.payload_size() < sizeof(UDPPacket)) {
|
|
|
|
kprintf("handle_udp: Packet too small (%u, need %zu)\n", ipv4_packet.payload_size());
|
|
|
|
return;
|
|
|
|
}
|
2019-03-13 13:22:27 +00:00
|
|
|
|
2019-08-09 02:34:32 +00:00
|
|
|
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
|
2019-03-13 13:22:27 +00:00
|
|
|
if (!adapter) {
|
|
|
|
kprintf("handle_udp: this packet is not for me, it's for %s\n", ipv4_packet.destination().to_string().characters());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
|
|
|
|
#ifdef UDP_DEBUG
|
|
|
|
kprintf("handle_udp: source=%s:%u, destination=%s:%u length=%u\n",
|
|
|
|
ipv4_packet.source().to_string().characters(),
|
|
|
|
udp_packet.source_port(),
|
|
|
|
ipv4_packet.destination().to_string().characters(),
|
|
|
|
udp_packet.destination_port(),
|
2019-06-07 09:43:58 +00:00
|
|
|
udp_packet.length());
|
2019-03-13 13:22:27 +00:00
|
|
|
#endif
|
|
|
|
|
2019-03-14 11:43:18 +00:00
|
|
|
auto socket = UDPSocket::from_port(udp_packet.destination_port());
|
2019-03-14 08:19:24 +00:00
|
|
|
if (!socket) {
|
|
|
|
kprintf("handle_udp: No UDP socket for port %u\n", udp_packet.destination_port());
|
|
|
|
return;
|
2019-03-13 13:22:27 +00:00
|
|
|
}
|
2019-03-13 15:23:22 +00:00
|
|
|
|
|
|
|
ASSERT(socket->type() == SOCK_DGRAM);
|
2019-05-04 14:40:34 +00:00
|
|
|
ASSERT(socket->local_port() == udp_packet.destination_port());
|
2019-08-04 19:07:50 +00:00
|
|
|
socket->did_receive(ipv4_packet.source(), udp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
|
2019-03-13 13:22:27 +00:00
|
|
|
}
|
2019-03-13 16:17:07 +00:00
|
|
|
|
2019-08-09 08:42:01 +00:00
|
|
|
void handle_tcp(const IPv4Packet& ipv4_packet)
|
2019-03-13 16:17:07 +00:00
|
|
|
{
|
2019-08-09 08:42:01 +00:00
|
|
|
if (ipv4_packet.payload_size() < sizeof(TCPPacket)) {
|
|
|
|
kprintf("handle_tcp: IPv4 payload is too small to be a TCP packet (%u, need %zu)\n", ipv4_packet.payload_size(), sizeof(TCPPacket));
|
2019-03-13 16:17:07 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
|
2019-08-09 08:42:01 +00:00
|
|
|
|
|
|
|
size_t minimum_tcp_header_size = 5 * sizeof(u32);
|
|
|
|
size_t maximum_tcp_header_size = 15 * sizeof(u32);
|
|
|
|
if (tcp_packet.header_size() < minimum_tcp_header_size || tcp_packet.header_size() > maximum_tcp_header_size) {
|
|
|
|
kprintf("handle_tcp: TCP packet header has invalid size %zu\n", tcp_packet.header_size());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ipv4_packet.payload_size() < tcp_packet.header_size()) {
|
|
|
|
kprintf("handle_tcp: IPv4 payload is smaller than TCP header claims (%u, supposedly %u)\n", ipv4_packet.payload_size(), tcp_packet.header_size());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-14 00:42:29 +00:00
|
|
|
size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size();
|
|
|
|
|
2019-03-13 16:17:07 +00:00
|
|
|
#ifdef TCP_DEBUG
|
2019-08-06 13:40:38 +00:00
|
|
|
kprintf("handle_tcp: source=%s:%u, destination=%s:%u seq_no=%u, ack_no=%u, flags=%w (%s%s%s%s), window_size=%u, payload_size=%u\n",
|
2019-03-13 16:17:07 +00:00
|
|
|
ipv4_packet.source().to_string().characters(),
|
|
|
|
tcp_packet.source_port(),
|
|
|
|
ipv4_packet.destination().to_string().characters(),
|
|
|
|
tcp_packet.destination_port(),
|
|
|
|
tcp_packet.sequence_number(),
|
|
|
|
tcp_packet.ack_number(),
|
|
|
|
tcp_packet.flags(),
|
2019-08-06 13:40:38 +00:00
|
|
|
tcp_packet.has_syn() ? "SYN " : "",
|
|
|
|
tcp_packet.has_ack() ? "ACK " : "",
|
|
|
|
tcp_packet.has_fin() ? "FIN " : "",
|
|
|
|
tcp_packet.has_rst() ? "RST " : "",
|
2019-03-14 00:42:29 +00:00
|
|
|
tcp_packet.window_size(),
|
2019-06-07 09:43:58 +00:00
|
|
|
payload_size);
|
2019-03-13 16:17:07 +00:00
|
|
|
#endif
|
|
|
|
|
2019-08-09 08:42:01 +00:00
|
|
|
auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
|
|
|
|
if (!adapter) {
|
|
|
|
kprintf("handle_tcp: this packet is not for me, it's for %s\n", ipv4_packet.destination().to_string().characters());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-08-06 13:40:38 +00:00
|
|
|
IPv4SocketTuple tuple(ipv4_packet.destination(), tcp_packet.destination_port(), ipv4_packet.source(), tcp_packet.source_port());
|
|
|
|
|
2019-08-09 02:35:56 +00:00
|
|
|
#ifdef TCP_DEBUG
|
|
|
|
kprintf("handle_tcp: looking for socket; tuple=%s\n", tuple.to_string().characters());
|
|
|
|
#endif
|
|
|
|
|
2019-08-06 13:40:38 +00:00
|
|
|
auto socket = TCPSocket::from_tuple(tuple);
|
2019-03-14 08:19:24 +00:00
|
|
|
if (!socket) {
|
2019-08-06 13:40:38 +00:00
|
|
|
kprintf("handle_tcp: No TCP socket for tuple %s\n", tuple.to_string().characters());
|
2019-12-14 12:03:26 +00:00
|
|
|
kprintf("handle_tcp: source=%s:%u, destination=%s:%u seq_no=%u, ack_no=%u, flags=%w (%s%s%s%s), window_size=%u, payload_size=%u\n",
|
|
|
|
ipv4_packet.source().to_string().characters(),
|
|
|
|
tcp_packet.source_port(),
|
|
|
|
ipv4_packet.destination().to_string().characters(),
|
|
|
|
tcp_packet.destination_port(),
|
|
|
|
tcp_packet.sequence_number(),
|
|
|
|
tcp_packet.ack_number(),
|
|
|
|
tcp_packet.flags(),
|
|
|
|
tcp_packet.has_syn() ? "SYN " : "",
|
|
|
|
tcp_packet.has_ack() ? "ACK " : "",
|
|
|
|
tcp_packet.has_fin() ? "FIN " : "",
|
|
|
|
tcp_packet.has_rst() ? "RST " : "",
|
|
|
|
tcp_packet.window_size(),
|
|
|
|
payload_size);
|
2019-03-14 08:19:24 +00:00
|
|
|
return;
|
2019-03-13 16:17:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(socket->type() == SOCK_STREAM);
|
2019-05-04 14:40:34 +00:00
|
|
|
ASSERT(socket->local_port() == tcp_packet.destination_port());
|
2019-03-13 22:14:30 +00:00
|
|
|
|
2019-08-09 02:35:56 +00:00
|
|
|
#ifdef TCP_DEBUG
|
|
|
|
kprintf("handle_tcp: got socket; state=%s\n", socket->tuple().to_string().characters(), TCPSocket::to_string(socket->state()));
|
|
|
|
#endif
|
|
|
|
|
2019-09-08 07:38:08 +00:00
|
|
|
socket->receive_tcp_packet(tcp_packet, ipv4_packet.payload_size());
|
2019-08-08 02:32:35 +00:00
|
|
|
|
2019-08-06 13:40:38 +00:00
|
|
|
switch (socket->state()) {
|
|
|
|
case TCPSocket::State::Closed:
|
|
|
|
kprintf("handle_tcp: unexpected flags in Closed state\n");
|
2019-08-08 02:29:34 +00:00
|
|
|
// TODO: we may want to send an RST here, maybe as a configurable option
|
2019-03-14 14:23:32 +00:00
|
|
|
return;
|
2019-08-06 13:40:38 +00:00
|
|
|
case TCPSocket::State::TimeWait:
|
|
|
|
kprintf("handle_tcp: unexpected flags in TimeWait state\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
case TCPSocket::State::Listen:
|
|
|
|
switch (tcp_packet.flags()) {
|
2019-08-09 02:48:28 +00:00
|
|
|
case TCPFlags::SYN: {
|
2019-09-08 09:13:50 +00:00
|
|
|
#ifdef TCP_DEBUG
|
2019-08-09 02:48:28 +00:00
|
|
|
kprintf("handle_tcp: incoming connection\n");
|
2019-09-08 09:13:50 +00:00
|
|
|
#endif
|
2019-08-09 02:48:28 +00:00
|
|
|
auto& local_address = ipv4_packet.destination();
|
|
|
|
auto& peer_address = ipv4_packet.source();
|
|
|
|
auto client = socket->create_client(local_address, tcp_packet.destination_port(), peer_address, tcp_packet.source_port());
|
|
|
|
if (!client) {
|
|
|
|
kprintf("handle_tcp: couldn't create client socket\n");
|
|
|
|
return;
|
|
|
|
}
|
2019-09-08 09:13:50 +00:00
|
|
|
#ifdef TCP_DEBUG
|
2019-08-09 02:48:28 +00:00
|
|
|
kprintf("handle_tcp: created new client socket with tuple %s\n", client->tuple().to_string().characters());
|
2019-09-08 09:13:50 +00:00
|
|
|
#endif
|
2019-08-09 02:48:28 +00:00
|
|
|
client->set_sequence_number(1000);
|
|
|
|
client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
|
|
|
|
client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
|
|
|
|
client->set_state(TCPSocket::State::SynReceived);
|
2019-08-06 13:40:38 +00:00
|
|
|
return;
|
2019-08-09 02:48:28 +00:00
|
|
|
}
|
2019-08-06 13:40:38 +00:00
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: unexpected flags in Listen state\n");
|
|
|
|
// socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TCPSocket::State::SynSent:
|
|
|
|
switch (tcp_packet.flags()) {
|
|
|
|
case TCPFlags::SYN:
|
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
|
|
|
|
socket->send_tcp_packet(TCPFlags::ACK);
|
|
|
|
socket->set_state(TCPSocket::State::SynReceived);
|
|
|
|
return;
|
2019-08-10 03:18:18 +00:00
|
|
|
case TCPFlags::ACK | TCPFlags::SYN:
|
2019-08-06 13:40:38 +00:00
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
|
|
|
|
socket->send_tcp_packet(TCPFlags::ACK);
|
|
|
|
socket->set_state(TCPSocket::State::Established);
|
2019-08-10 03:17:00 +00:00
|
|
|
socket->set_setup_state(Socket::SetupState::Completed);
|
2019-08-06 13:40:38 +00:00
|
|
|
socket->set_connected(true);
|
|
|
|
return;
|
2019-08-10 03:18:18 +00:00
|
|
|
case TCPFlags::ACK | TCPFlags::FIN:
|
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
|
|
|
|
socket->send_tcp_packet(TCPFlags::ACK);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
socket->set_error(TCPSocket::Error::FINDuringConnect);
|
|
|
|
socket->set_setup_state(Socket::SetupState::Completed);
|
|
|
|
return;
|
|
|
|
case TCPFlags::ACK | TCPFlags::RST:
|
2019-09-08 07:02:40 +00:00
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
|
2019-08-10 03:18:18 +00:00
|
|
|
socket->send_tcp_packet(TCPFlags::ACK);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
socket->set_error(TCPSocket::Error::RSTDuringConnect);
|
|
|
|
socket->set_setup_state(Socket::SetupState::Completed);
|
|
|
|
return;
|
2019-08-06 13:40:38 +00:00
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: unexpected flags in SynSent state\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
2019-08-10 03:18:18 +00:00
|
|
|
socket->set_error(TCPSocket::Error::UnexpectedFlagsDuringConnect);
|
2019-08-10 03:17:00 +00:00
|
|
|
socket->set_setup_state(Socket::SetupState::Completed);
|
2019-08-06 13:40:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TCPSocket::State::SynReceived:
|
|
|
|
switch (tcp_packet.flags()) {
|
|
|
|
case TCPFlags::ACK:
|
2019-09-08 07:02:40 +00:00
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
|
2019-09-08 09:37:05 +00:00
|
|
|
|
|
|
|
switch (socket->direction()) {
|
|
|
|
case TCPSocket::Direction::Incoming:
|
|
|
|
if (!socket->has_originator()) {
|
|
|
|
kprintf("handle_tcp: connection doesn't have an originating socket; maybe it went away?\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
socket->set_state(TCPSocket::State::Established);
|
|
|
|
socket->set_setup_state(Socket::SetupState::Completed);
|
|
|
|
socket->release_to_originator();
|
|
|
|
return;
|
|
|
|
case TCPSocket::Direction::Outgoing:
|
|
|
|
socket->set_state(TCPSocket::State::Established);
|
|
|
|
socket->set_setup_state(Socket::SetupState::Completed);
|
2019-08-09 02:48:28 +00:00
|
|
|
socket->set_connected(true);
|
2019-09-08 09:37:05 +00:00
|
|
|
return;
|
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: got ACK in SynReceived state but direction is invalid (%s)\n", TCPSocket::to_string(socket->direction()));
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-08-06 13:40:38 +00:00
|
|
|
return;
|
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: unexpected flags in SynReceived state\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TCPSocket::State::CloseWait:
|
|
|
|
switch (tcp_packet.flags()) {
|
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: unexpected flags in CloseWait state\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TCPSocket::State::LastAck:
|
|
|
|
switch (tcp_packet.flags()) {
|
|
|
|
case TCPFlags::ACK:
|
2019-09-08 07:02:40 +00:00
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
|
2019-08-06 13:40:38 +00:00
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: unexpected flags in LastAck state\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TCPSocket::State::FinWait1:
|
|
|
|
switch (tcp_packet.flags()) {
|
|
|
|
case TCPFlags::ACK:
|
2019-09-08 07:02:40 +00:00
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
|
2019-08-06 13:40:38 +00:00
|
|
|
socket->set_state(TCPSocket::State::FinWait2);
|
|
|
|
return;
|
|
|
|
case TCPFlags::FIN:
|
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
|
|
|
|
socket->set_state(TCPSocket::State::Closing);
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: unexpected flags in FinWait1 state\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TCPSocket::State::FinWait2:
|
|
|
|
switch (tcp_packet.flags()) {
|
|
|
|
case TCPFlags::FIN:
|
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
|
|
|
|
socket->set_state(TCPSocket::State::TimeWait);
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: unexpected flags in FinWait2 state\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TCPSocket::State::Closing:
|
|
|
|
switch (tcp_packet.flags()) {
|
|
|
|
case TCPFlags::ACK:
|
2019-09-08 07:02:40 +00:00
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
|
2019-08-06 13:40:38 +00:00
|
|
|
socket->set_state(TCPSocket::State::TimeWait);
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
kprintf("handle_tcp: unexpected flags in Closing state\n");
|
|
|
|
socket->send_tcp_packet(TCPFlags::RST);
|
|
|
|
socket->set_state(TCPSocket::State::Closed);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
case TCPSocket::State::Established:
|
|
|
|
if (tcp_packet.has_fin()) {
|
|
|
|
if (payload_size != 0)
|
|
|
|
socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
|
|
|
|
|
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
|
2019-09-08 07:42:19 +00:00
|
|
|
// TODO: We should only send a FIN packet out once we're shutting
|
|
|
|
// down our side of the socket, so we should change this back to
|
|
|
|
// just being an ACK and a transition to CloseWait once we have a
|
|
|
|
// shutdown() implementation.
|
|
|
|
socket->send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
|
|
|
|
socket->set_state(TCPSocket::State::Closing);
|
2019-08-06 13:40:38 +00:00
|
|
|
socket->set_connected(false);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
|
2019-03-14 14:23:32 +00:00
|
|
|
|
2019-08-04 08:04:06 +00:00
|
|
|
#ifdef TCP_DEBUG
|
2019-08-06 13:40:38 +00:00
|
|
|
kprintf("Got packet with ack_no=%u, seq_no=%u, payload_size=%u, acking it with new ack_no=%u, seq_no=%u\n",
|
|
|
|
tcp_packet.ack_number(),
|
|
|
|
tcp_packet.sequence_number(),
|
|
|
|
payload_size,
|
|
|
|
socket->ack_number(),
|
|
|
|
socket->sequence_number());
|
2019-08-04 08:04:06 +00:00
|
|
|
#endif
|
2019-03-13 23:20:44 +00:00
|
|
|
|
2019-11-04 13:03:14 +00:00
|
|
|
bool should_ack = true;
|
|
|
|
if (payload_size != 0) {
|
|
|
|
should_ack = socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
|
|
|
|
}
|
2019-08-06 13:40:38 +00:00
|
|
|
|
2019-11-04 13:03:14 +00:00
|
|
|
if (should_ack)
|
|
|
|
socket->send_tcp_packet(TCPFlags::ACK);
|
2019-08-06 13:40:38 +00:00
|
|
|
}
|
2019-03-13 16:17:07 +00:00
|
|
|
}
|