NetworkTask.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545
  1. #include <Kernel/Lock.h>
  2. #include <Kernel/Net/ARP.h>
  3. #include <Kernel/Net/E1000NetworkAdapter.h>
  4. #include <Kernel/Net/EtherType.h>
  5. #include <Kernel/Net/EthernetFrameHeader.h>
  6. #include <Kernel/Net/ICMP.h>
  7. #include <Kernel/Net/IPv4.h>
  8. #include <Kernel/Net/IPv4Socket.h>
  9. #include <Kernel/Net/LoopbackAdapter.h>
  10. #include <Kernel/Net/TCP.h>
  11. #include <Kernel/Net/TCPSocket.h>
  12. #include <Kernel/Net/UDP.h>
  13. #include <Kernel/Net/UDPSocket.h>
  14. #include <Kernel/Process.h>
  15. //#define ETHERNET_DEBUG
  16. //#define ETHERNET_VERY_DEBUG
  17. //#define IPV4_DEBUG
  18. //#define ICMP_DEBUG
  19. //#define UDP_DEBUG
  20. //#define TCP_DEBUG
  21. static void handle_arp(const EthernetFrameHeader&, size_t frame_size);
  22. static void handle_ipv4(const EthernetFrameHeader&, size_t frame_size);
  23. static void handle_icmp(const EthernetFrameHeader&, const IPv4Packet&);
  24. static void handle_udp(const IPv4Packet&);
  25. static void handle_tcp(const IPv4Packet&);
  26. Lockable<HashMap<IPv4Address, MACAddress>>& arp_table()
  27. {
  28. static Lockable<HashMap<IPv4Address, MACAddress>>* the;
  29. if (!the)
  30. the = new Lockable<HashMap<IPv4Address, MACAddress>>;
  31. return *the;
  32. }
  33. void NetworkTask_main()
  34. {
  35. LoopbackAdapter::the();
  36. auto adapter = E1000NetworkAdapter::the();
  37. if (!adapter)
  38. dbgprintf("E1000 network card not found!\n");
  39. if (adapter)
  40. adapter->set_ipv4_address(IPv4Address(192, 168, 5, 2));
  41. auto dequeue_packet = [&]() -> Optional<KBuffer> {
  42. auto packet = LoopbackAdapter::the().dequeue_packet();
  43. if (packet.has_value()) {
  44. dbgprintf("Receive loopback packet (%d bytes)\n", packet.value().size());
  45. return packet.value();
  46. }
  47. if (adapter && adapter->has_queued_packets())
  48. return adapter->dequeue_packet();
  49. return {};
  50. };
  51. kprintf("NetworkTask: Enter main loop.\n");
  52. for (;;) {
  53. auto packet_maybe_null = dequeue_packet();
  54. if (!packet_maybe_null.has_value()) {
  55. (void)current->block_until("Networking", [] {
  56. if (LoopbackAdapter::the().has_queued_packets())
  57. return true;
  58. if (auto* e1000 = E1000NetworkAdapter::the()) {
  59. if (e1000->has_queued_packets())
  60. return true;
  61. }
  62. return false;
  63. });
  64. continue;
  65. }
  66. auto& packet = packet_maybe_null.value();
  67. if (packet.size() < sizeof(EthernetFrameHeader)) {
  68. kprintf("NetworkTask: Packet is too small to be an Ethernet packet! (%zu)\n", packet.size());
  69. continue;
  70. }
  71. auto& eth = *(const EthernetFrameHeader*)packet.data();
  72. #ifdef ETHERNET_DEBUG
  73. kprintf("NetworkTask: From %s to %s, ether_type=%w, packet_length=%u\n",
  74. eth.source().to_string().characters(),
  75. eth.destination().to_string().characters(),
  76. eth.ether_type(),
  77. packet.size());
  78. #endif
  79. #ifdef ETHERNET_VERY_DEBUG
  80. u8* data = packet.data();
  81. for (size_t i = 0; i < packet.size(); i++) {
  82. kprintf("%b", data[i]);
  83. switch (i % 16) {
  84. case 7:
  85. kprintf(" ");
  86. break;
  87. case 15:
  88. kprintf("\n");
  89. break;
  90. default:
  91. kprintf(" ");
  92. break;
  93. }
  94. }
  95. kprintf("\n");
  96. #endif
  97. switch (eth.ether_type()) {
  98. case EtherType::ARP:
  99. handle_arp(eth, packet.size());
  100. break;
  101. case EtherType::IPv4:
  102. handle_ipv4(eth, packet.size());
  103. break;
  104. }
  105. }
  106. }
  107. void handle_arp(const EthernetFrameHeader& eth, size_t frame_size)
  108. {
  109. constexpr size_t minimum_arp_frame_size = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
  110. if (frame_size < minimum_arp_frame_size) {
  111. kprintf("handle_arp: Frame too small (%d, need %d)\n", frame_size, minimum_arp_frame_size);
  112. return;
  113. }
  114. auto& packet = *static_cast<const ARPPacket*>(eth.payload());
  115. if (packet.hardware_type() != 1 || packet.hardware_address_length() != sizeof(MACAddress)) {
  116. kprintf("handle_arp: Hardware type not ethernet (%w, len=%u)\n",
  117. packet.hardware_type(),
  118. packet.hardware_address_length());
  119. return;
  120. }
  121. if (packet.protocol_type() != EtherType::IPv4 || packet.protocol_address_length() != sizeof(IPv4Address)) {
  122. kprintf("handle_arp: Protocol type not IPv4 (%w, len=%u)\n",
  123. packet.hardware_type(),
  124. packet.protocol_address_length());
  125. return;
  126. }
  127. #ifdef ARP_DEBUG
  128. kprintf("handle_arp: operation=%w, sender=%s/%s, target=%s/%s\n",
  129. packet.operation(),
  130. packet.sender_hardware_address().to_string().characters(),
  131. packet.sender_protocol_address().to_string().characters(),
  132. packet.target_hardware_address().to_string().characters(),
  133. packet.target_protocol_address().to_string().characters());
  134. #endif
  135. if (packet.operation() == ARPOperation::Request) {
  136. // Who has this IP address?
  137. if (auto adapter = NetworkAdapter::from_ipv4_address(packet.target_protocol_address())) {
  138. // We do!
  139. kprintf("handle_arp: Responding to ARP request for my IPv4 address (%s)\n",
  140. adapter->ipv4_address().to_string().characters());
  141. ARPPacket response;
  142. response.set_operation(ARPOperation::Response);
  143. response.set_target_hardware_address(packet.sender_hardware_address());
  144. response.set_target_protocol_address(packet.sender_protocol_address());
  145. response.set_sender_hardware_address(adapter->mac_address());
  146. response.set_sender_protocol_address(adapter->ipv4_address());
  147. adapter->send(packet.sender_hardware_address(), response);
  148. }
  149. return;
  150. }
  151. if (packet.operation() == ARPOperation::Response) {
  152. // Someone has this IPv4 address. I guess we can try to remember that.
  153. // FIXME: Protect against ARP spamming.
  154. // FIXME: Support static ARP table entries.
  155. LOCKER(arp_table().lock());
  156. arp_table().resource().set(packet.sender_protocol_address(), packet.sender_hardware_address());
  157. kprintf("ARP table (%d entries):\n", arp_table().resource().size());
  158. for (auto& it : arp_table().resource()) {
  159. kprintf("%s :: %s\n", it.value.to_string().characters(), it.key.to_string().characters());
  160. }
  161. }
  162. }
  163. void handle_ipv4(const EthernetFrameHeader& eth, size_t frame_size)
  164. {
  165. constexpr size_t minimum_ipv4_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet);
  166. if (frame_size < minimum_ipv4_frame_size) {
  167. kprintf("handle_ipv4: Frame too small (%d, need %d)\n", frame_size, minimum_ipv4_frame_size);
  168. return;
  169. }
  170. auto& packet = *static_cast<const IPv4Packet*>(eth.payload());
  171. if (packet.length() < sizeof(IPv4Packet)) {
  172. kprintf("handle_ipv4: IPv4 packet too short (%u, need %u)\n", packet.length(), sizeof(IPv4Packet));
  173. return;
  174. }
  175. size_t actual_ipv4_packet_length = frame_size - sizeof(EthernetFrameHeader);
  176. if (packet.length() > actual_ipv4_packet_length) {
  177. kprintf("handle_ipv4: IPv4 packet claims to be longer than it is (%u, actually %zu)\n", packet.length(), actual_ipv4_packet_length);
  178. return;
  179. }
  180. #ifdef IPV4_DEBUG
  181. kprintf("handle_ipv4: source=%s, target=%s\n",
  182. packet.source().to_string().characters(),
  183. packet.destination().to_string().characters());
  184. #endif
  185. switch ((IPv4Protocol)packet.protocol()) {
  186. case IPv4Protocol::ICMP:
  187. return handle_icmp(eth, packet);
  188. case IPv4Protocol::UDP:
  189. return handle_udp(packet);
  190. case IPv4Protocol::TCP:
  191. return handle_tcp(packet);
  192. default:
  193. kprintf("handle_ipv4: Unhandled protocol %u\n", packet.protocol());
  194. break;
  195. }
  196. }
  197. void handle_icmp(const EthernetFrameHeader& eth, const IPv4Packet& ipv4_packet)
  198. {
  199. auto& icmp_header = *static_cast<const ICMPHeader*>(ipv4_packet.payload());
  200. #ifdef ICMP_DEBUG
  201. kprintf("handle_icmp: source=%s, destination=%s, type=%b, code=%b\n",
  202. ipv4_packet.source().to_string().characters(),
  203. ipv4_packet.destination().to_string().characters(),
  204. icmp_header.type(),
  205. icmp_header.code());
  206. #endif
  207. {
  208. LOCKER(IPv4Socket::all_sockets().lock());
  209. for (RefPtr<IPv4Socket> socket : IPv4Socket::all_sockets().resource()) {
  210. LOCKER(socket->lock());
  211. if (socket->protocol() != (unsigned)IPv4Protocol::ICMP)
  212. continue;
  213. socket->did_receive(ipv4_packet.source(), 0, KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
  214. }
  215. }
  216. auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
  217. if (!adapter)
  218. return;
  219. if (icmp_header.type() == ICMPType::EchoRequest) {
  220. auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header);
  221. kprintf("handle_icmp: EchoRequest from %s: id=%u, seq=%u\n",
  222. ipv4_packet.source().to_string().characters(),
  223. (u16)request.identifier,
  224. (u16)request.sequence_number);
  225. size_t icmp_packet_size = ipv4_packet.payload_size();
  226. auto buffer = ByteBuffer::create_zeroed(icmp_packet_size);
  227. auto& response = *(ICMPEchoPacket*)buffer.pointer();
  228. response.header.set_type(ICMPType::EchoReply);
  229. response.header.set_code(0);
  230. response.identifier = request.identifier;
  231. response.sequence_number = request.sequence_number;
  232. if (size_t icmp_payload_size = icmp_packet_size - sizeof(ICMPEchoPacket))
  233. memcpy(response.payload(), request.payload(), icmp_payload_size);
  234. response.header.set_checksum(internet_checksum(&response, icmp_packet_size));
  235. adapter->send_ipv4(eth.source(), ipv4_packet.source(), IPv4Protocol::ICMP, buffer.data(), buffer.size());
  236. }
  237. }
  238. void handle_udp(const IPv4Packet& ipv4_packet)
  239. {
  240. if (ipv4_packet.payload_size() < sizeof(UDPPacket)) {
  241. kprintf("handle_udp: Packet too small (%u, need %zu)\n", ipv4_packet.payload_size());
  242. return;
  243. }
  244. auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
  245. if (!adapter) {
  246. kprintf("handle_udp: this packet is not for me, it's for %s\n", ipv4_packet.destination().to_string().characters());
  247. return;
  248. }
  249. auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
  250. #ifdef UDP_DEBUG
  251. kprintf("handle_udp: source=%s:%u, destination=%s:%u length=%u\n",
  252. ipv4_packet.source().to_string().characters(),
  253. udp_packet.source_port(),
  254. ipv4_packet.destination().to_string().characters(),
  255. udp_packet.destination_port(),
  256. udp_packet.length());
  257. #endif
  258. auto socket = UDPSocket::from_port(udp_packet.destination_port());
  259. if (!socket) {
  260. kprintf("handle_udp: No UDP socket for port %u\n", udp_packet.destination_port());
  261. return;
  262. }
  263. ASSERT(socket->type() == SOCK_DGRAM);
  264. ASSERT(socket->local_port() == udp_packet.destination_port());
  265. socket->did_receive(ipv4_packet.source(), udp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
  266. }
  267. void handle_tcp(const IPv4Packet& ipv4_packet)
  268. {
  269. if (ipv4_packet.payload_size() < sizeof(TCPPacket)) {
  270. kprintf("handle_tcp: IPv4 payload is too small to be a TCP packet (%u, need %zu)\n", ipv4_packet.payload_size(), sizeof(TCPPacket));
  271. return;
  272. }
  273. auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
  274. size_t minimum_tcp_header_size = 5 * sizeof(u32);
  275. size_t maximum_tcp_header_size = 15 * sizeof(u32);
  276. if (tcp_packet.header_size() < minimum_tcp_header_size || tcp_packet.header_size() > maximum_tcp_header_size) {
  277. kprintf("handle_tcp: TCP packet header has invalid size %zu\n", tcp_packet.header_size());
  278. }
  279. if (ipv4_packet.payload_size() < tcp_packet.header_size()) {
  280. kprintf("handle_tcp: IPv4 payload is smaller than TCP header claims (%u, supposedly %u)\n", ipv4_packet.payload_size(), tcp_packet.header_size());
  281. return;
  282. }
  283. size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size();
  284. #ifdef TCP_DEBUG
  285. 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",
  286. ipv4_packet.source().to_string().characters(),
  287. tcp_packet.source_port(),
  288. ipv4_packet.destination().to_string().characters(),
  289. tcp_packet.destination_port(),
  290. tcp_packet.sequence_number(),
  291. tcp_packet.ack_number(),
  292. tcp_packet.flags(),
  293. tcp_packet.has_syn() ? "SYN " : "",
  294. tcp_packet.has_ack() ? "ACK " : "",
  295. tcp_packet.has_fin() ? "FIN " : "",
  296. tcp_packet.has_rst() ? "RST " : "",
  297. tcp_packet.window_size(),
  298. payload_size);
  299. #endif
  300. auto adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
  301. if (!adapter) {
  302. kprintf("handle_tcp: this packet is not for me, it's for %s\n", ipv4_packet.destination().to_string().characters());
  303. return;
  304. }
  305. IPv4SocketTuple tuple(ipv4_packet.destination(), tcp_packet.destination_port(), ipv4_packet.source(), tcp_packet.source_port());
  306. #ifdef TCP_DEBUG
  307. kprintf("handle_tcp: looking for socket; tuple=%s\n", tuple.to_string().characters());
  308. #endif
  309. auto socket = TCPSocket::from_tuple(tuple);
  310. if (!socket) {
  311. kprintf("handle_tcp: No TCP socket for tuple %s\n", tuple.to_string().characters());
  312. return;
  313. }
  314. ASSERT(socket->type() == SOCK_STREAM);
  315. ASSERT(socket->local_port() == tcp_packet.destination_port());
  316. #ifdef TCP_DEBUG
  317. kprintf("handle_tcp: got socket; state=%s\n", socket->tuple().to_string().characters(), TCPSocket::to_string(socket->state()));
  318. #endif
  319. if (tcp_packet.ack_number() != socket->sequence_number()) {
  320. kprintf("handle_tcp: ack/seq mismatch: got %u, wanted %u\n", tcp_packet.ack_number(), socket->sequence_number());
  321. return;
  322. }
  323. socket->record_incoming_data(ipv4_packet.payload_size());
  324. switch (socket->state()) {
  325. case TCPSocket::State::Closed:
  326. kprintf("handle_tcp: unexpected flags in Closed state\n");
  327. // TODO: we may want to send an RST here, maybe as a configurable option
  328. return;
  329. case TCPSocket::State::TimeWait:
  330. kprintf("handle_tcp: unexpected flags in TimeWait state\n");
  331. socket->send_tcp_packet(TCPFlags::RST);
  332. socket->set_state(TCPSocket::State::Closed);
  333. kprintf("handle_tcp: TimeWait -> Closed\n");
  334. return;
  335. case TCPSocket::State::Listen:
  336. switch (tcp_packet.flags()) {
  337. case TCPFlags::SYN: {
  338. kprintf("handle_tcp: incoming connection\n");
  339. auto& local_address = ipv4_packet.destination();
  340. auto& peer_address = ipv4_packet.source();
  341. auto client = socket->create_client(local_address, tcp_packet.destination_port(), peer_address, tcp_packet.source_port());
  342. if (!client) {
  343. kprintf("handle_tcp: couldn't create client socket\n");
  344. return;
  345. }
  346. kprintf("handle_tcp: created new client socket with tuple %s\n", client->tuple().to_string().characters());
  347. client->set_sequence_number(1000);
  348. client->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  349. client->send_tcp_packet(TCPFlags::SYN | TCPFlags::ACK);
  350. client->set_sequence_number(1001);
  351. client->set_state(TCPSocket::State::SynReceived);
  352. kprintf("handle_tcp: Closed -> SynReceived\n");
  353. return;
  354. }
  355. default:
  356. kprintf("handle_tcp: unexpected flags in Listen state\n");
  357. // socket->send_tcp_packet(TCPFlags::RST);
  358. return;
  359. }
  360. case TCPSocket::State::SynSent:
  361. switch (tcp_packet.flags()) {
  362. case TCPFlags::SYN:
  363. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  364. socket->send_tcp_packet(TCPFlags::ACK);
  365. socket->set_state(TCPSocket::State::SynReceived);
  366. kprintf("handle_tcp: SynSent -> SynReceived\n");
  367. return;
  368. case TCPFlags::SYN | TCPFlags::ACK:
  369. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  370. socket->send_tcp_packet(TCPFlags::ACK);
  371. socket->set_state(TCPSocket::State::Established);
  372. socket->set_connected(true);
  373. kprintf("handle_tcp: SynSent -> Established\n");
  374. return;
  375. default:
  376. kprintf("handle_tcp: unexpected flags in SynSent state\n");
  377. socket->send_tcp_packet(TCPFlags::RST);
  378. socket->set_state(TCPSocket::State::Closed);
  379. kprintf("handle_tcp: SynSent -> Closed\n");
  380. return;
  381. }
  382. case TCPSocket::State::SynReceived:
  383. switch (tcp_packet.flags()) {
  384. case TCPFlags::ACK:
  385. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  386. socket->set_state(TCPSocket::State::Established);
  387. if (socket->direction() == TCPSocket::Direction::Outgoing)
  388. socket->set_connected(true);
  389. kprintf("handle_tcp: SynReceived -> Established\n");
  390. return;
  391. default:
  392. kprintf("handle_tcp: unexpected flags in SynReceived state\n");
  393. socket->send_tcp_packet(TCPFlags::RST);
  394. socket->set_state(TCPSocket::State::Closed);
  395. kprintf("handle_tcp: SynReceived -> Closed\n");
  396. return;
  397. }
  398. case TCPSocket::State::CloseWait:
  399. switch (tcp_packet.flags()) {
  400. default:
  401. kprintf("handle_tcp: unexpected flags in CloseWait state\n");
  402. socket->send_tcp_packet(TCPFlags::RST);
  403. socket->set_state(TCPSocket::State::Closed);
  404. kprintf("handle_tcp: CloseWait -> Closed\n");
  405. return;
  406. }
  407. case TCPSocket::State::LastAck:
  408. switch (tcp_packet.flags()) {
  409. case TCPFlags::ACK:
  410. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  411. socket->set_state(TCPSocket::State::Closed);
  412. kprintf("handle_tcp: LastAck -> Closed\n");
  413. return;
  414. default:
  415. kprintf("handle_tcp: unexpected flags in LastAck state\n");
  416. socket->send_tcp_packet(TCPFlags::RST);
  417. socket->set_state(TCPSocket::State::Closed);
  418. kprintf("handle_tcp: LastAck -> Closed\n");
  419. return;
  420. }
  421. case TCPSocket::State::FinWait1:
  422. switch (tcp_packet.flags()) {
  423. case TCPFlags::ACK:
  424. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  425. socket->set_state(TCPSocket::State::FinWait2);
  426. kprintf("handle_tcp: FinWait1 -> FinWait2\n");
  427. return;
  428. case TCPFlags::FIN:
  429. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  430. socket->set_state(TCPSocket::State::Closing);
  431. kprintf("handle_tcp: FinWait1 -> Closing\n");
  432. return;
  433. default:
  434. kprintf("handle_tcp: unexpected flags in FinWait1 state\n");
  435. socket->send_tcp_packet(TCPFlags::RST);
  436. socket->set_state(TCPSocket::State::Closed);
  437. kprintf("handle_tcp: FinWait1 -> Closed\n");
  438. return;
  439. }
  440. case TCPSocket::State::FinWait2:
  441. switch (tcp_packet.flags()) {
  442. case TCPFlags::FIN:
  443. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  444. socket->set_state(TCPSocket::State::TimeWait);
  445. kprintf("handle_tcp: FinWait2 -> TimeWait\n");
  446. return;
  447. default:
  448. kprintf("handle_tcp: unexpected flags in FinWait2 state\n");
  449. socket->send_tcp_packet(TCPFlags::RST);
  450. socket->set_state(TCPSocket::State::Closed);
  451. kprintf("handle_tcp: FinWait2 -> Closed\n");
  452. return;
  453. }
  454. case TCPSocket::State::Closing:
  455. switch (tcp_packet.flags()) {
  456. case TCPFlags::ACK:
  457. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  458. socket->set_state(TCPSocket::State::TimeWait);
  459. kprintf("handle_tcp: Closing -> TimeWait\n");
  460. return;
  461. default:
  462. kprintf("handle_tcp: unexpected flags in Closing state\n");
  463. socket->send_tcp_packet(TCPFlags::RST);
  464. socket->set_state(TCPSocket::State::Closed);
  465. kprintf("handle_tcp: Closing -> Closed\n");
  466. return;
  467. }
  468. case TCPSocket::State::Established:
  469. if (tcp_packet.has_fin()) {
  470. if (payload_size != 0)
  471. socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
  472. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  473. socket->send_tcp_packet(TCPFlags::ACK);
  474. socket->set_state(TCPSocket::State::CloseWait);
  475. socket->set_connected(false);
  476. kprintf("handle_tcp: Established -> CloseWait\n");
  477. return;
  478. }
  479. socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
  480. #ifdef TCP_DEBUG
  481. kprintf("Got packet with ack_no=%u, seq_no=%u, payload_size=%u, acking it with new ack_no=%u, seq_no=%u\n",
  482. tcp_packet.ack_number(),
  483. tcp_packet.sequence_number(),
  484. payload_size,
  485. socket->ack_number(),
  486. socket->sequence_number());
  487. #endif
  488. socket->send_tcp_packet(TCPFlags::ACK);
  489. if (payload_size != 0)
  490. socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
  491. }
  492. }