NetworkTask.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345
  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 IPV4_DEBUG
  17. //#define ICMP_DEBUG
  18. //#define UDP_DEBUG
  19. //#define TCP_DEBUG
  20. static void handle_arp(const EthernetFrameHeader&, int frame_size);
  21. static void handle_ipv4(const EthernetFrameHeader&, int frame_size);
  22. static void handle_icmp(const EthernetFrameHeader&, int frame_size);
  23. static void handle_udp(const EthernetFrameHeader&, int frame_size);
  24. static void handle_tcp(const EthernetFrameHeader&, int frame_size);
  25. Lockable<HashMap<IPv4Address, MACAddress>>& arp_table()
  26. {
  27. static Lockable<HashMap<IPv4Address, MACAddress>>* the;
  28. if (!the)
  29. the = new Lockable<HashMap<IPv4Address, MACAddress>>;
  30. return *the;
  31. }
  32. void NetworkTask_main()
  33. {
  34. LoopbackAdapter::the();
  35. auto* adapter = E1000NetworkAdapter::the();
  36. if (!adapter)
  37. dbgprintf("E1000 network card not found!\n");
  38. if (adapter)
  39. adapter->set_ipv4_address(IPv4Address(192, 168, 5, 2));
  40. auto dequeue_packet = [&]() -> Optional<KBuffer> {
  41. auto packet = LoopbackAdapter::the().dequeue_packet();
  42. if (packet.has_value()) {
  43. dbgprintf("Receive loopback packet (%d bytes)\n", packet.value().size());
  44. return packet.value();
  45. }
  46. if (adapter && adapter->has_queued_packets())
  47. return adapter->dequeue_packet();
  48. return {};
  49. };
  50. kprintf("NetworkTask: Enter main loop.\n");
  51. for (;;) {
  52. auto packet_maybe_null = dequeue_packet();
  53. if (!packet_maybe_null.has_value()) {
  54. (void)current->block_until("Networking", [] {
  55. if (LoopbackAdapter::the().has_queued_packets())
  56. return true;
  57. if (auto* e1000 = E1000NetworkAdapter::the()) {
  58. if (e1000->has_queued_packets())
  59. return true;
  60. }
  61. return false;
  62. });
  63. continue;
  64. }
  65. auto& packet = packet_maybe_null.value();
  66. if (packet.size() < (int)(sizeof(EthernetFrameHeader))) {
  67. kprintf("NetworkTask: Packet is too small to be an Ethernet packet! (%d)\n", packet.size());
  68. continue;
  69. }
  70. auto& eth = *(const EthernetFrameHeader*)packet.data();
  71. #ifdef ETHERNET_DEBUG
  72. kprintf("NetworkTask: From %s to %s, ether_type=%w, packet_length=%u\n",
  73. eth.source().to_string().characters(),
  74. eth.destination().to_string().characters(),
  75. eth.ether_type(),
  76. packet.size());
  77. #endif
  78. switch (eth.ether_type()) {
  79. case EtherType::ARP:
  80. handle_arp(eth, packet.size());
  81. break;
  82. case EtherType::IPv4:
  83. handle_ipv4(eth, packet.size());
  84. break;
  85. }
  86. }
  87. }
  88. void handle_arp(const EthernetFrameHeader& eth, int frame_size)
  89. {
  90. constexpr int minimum_arp_frame_size = sizeof(EthernetFrameHeader) + sizeof(ARPPacket);
  91. if (frame_size < minimum_arp_frame_size) {
  92. kprintf("handle_arp: Frame too small (%d, need %d)\n", frame_size, minimum_arp_frame_size);
  93. return;
  94. }
  95. auto& packet = *static_cast<const ARPPacket*>(eth.payload());
  96. if (packet.hardware_type() != 1 || packet.hardware_address_length() != sizeof(MACAddress)) {
  97. kprintf("handle_arp: Hardware type not ethernet (%w, len=%u)\n",
  98. packet.hardware_type(),
  99. packet.hardware_address_length());
  100. return;
  101. }
  102. if (packet.protocol_type() != EtherType::IPv4 || packet.protocol_address_length() != sizeof(IPv4Address)) {
  103. kprintf("handle_arp: Protocol type not IPv4 (%w, len=%u)\n",
  104. packet.hardware_type(),
  105. packet.protocol_address_length());
  106. return;
  107. }
  108. #ifdef ARP_DEBUG
  109. kprintf("handle_arp: operation=%w, sender=%s/%s, target=%s/%s\n",
  110. packet.operation(),
  111. packet.sender_hardware_address().to_string().characters(),
  112. packet.sender_protocol_address().to_string().characters(),
  113. packet.target_hardware_address().to_string().characters(),
  114. packet.target_protocol_address().to_string().characters());
  115. #endif
  116. if (packet.operation() == ARPOperation::Request) {
  117. // Who has this IP address?
  118. if (auto* adapter = NetworkAdapter::from_ipv4_address(packet.target_protocol_address())) {
  119. // We do!
  120. kprintf("handle_arp: Responding to ARP request for my IPv4 address (%s)\n",
  121. adapter->ipv4_address().to_string().characters());
  122. ARPPacket response;
  123. response.set_operation(ARPOperation::Response);
  124. response.set_target_hardware_address(packet.sender_hardware_address());
  125. response.set_target_protocol_address(packet.sender_protocol_address());
  126. response.set_sender_hardware_address(adapter->mac_address());
  127. response.set_sender_protocol_address(adapter->ipv4_address());
  128. adapter->send(packet.sender_hardware_address(), response);
  129. }
  130. return;
  131. }
  132. if (packet.operation() == ARPOperation::Response) {
  133. // Someone has this IPv4 address. I guess we can try to remember that.
  134. // FIXME: Protect against ARP spamming.
  135. // FIXME: Support static ARP table entries.
  136. LOCKER(arp_table().lock());
  137. arp_table().resource().set(packet.sender_protocol_address(), packet.sender_hardware_address());
  138. kprintf("ARP table (%d entries):\n", arp_table().resource().size());
  139. for (auto& it : arp_table().resource()) {
  140. kprintf("%s :: %s\n", it.value.to_string().characters(), it.key.to_string().characters());
  141. }
  142. }
  143. }
  144. void handle_ipv4(const EthernetFrameHeader& eth, int frame_size)
  145. {
  146. constexpr int minimum_ipv4_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet);
  147. if (frame_size < minimum_ipv4_frame_size) {
  148. kprintf("handle_ipv4: Frame too small (%d, need %d)\n", frame_size, minimum_ipv4_frame_size);
  149. return;
  150. }
  151. auto& packet = *static_cast<const IPv4Packet*>(eth.payload());
  152. #ifdef IPV4_DEBUG
  153. kprintf("handle_ipv4: source=%s, target=%s\n",
  154. packet.source().to_string().characters(),
  155. packet.destination().to_string().characters());
  156. #endif
  157. switch ((IPv4Protocol)packet.protocol()) {
  158. case IPv4Protocol::ICMP:
  159. return handle_icmp(eth, frame_size);
  160. case IPv4Protocol::UDP:
  161. return handle_udp(eth, frame_size);
  162. case IPv4Protocol::TCP:
  163. return handle_tcp(eth, frame_size);
  164. default:
  165. kprintf("handle_ipv4: Unhandled protocol %u\n", packet.protocol());
  166. break;
  167. }
  168. }
  169. void handle_icmp(const EthernetFrameHeader& eth, int frame_size)
  170. {
  171. (void)frame_size;
  172. auto& ipv4_packet = *static_cast<const IPv4Packet*>(eth.payload());
  173. auto& icmp_header = *static_cast<const ICMPHeader*>(ipv4_packet.payload());
  174. #ifdef ICMP_DEBUG
  175. kprintf("handle_icmp: source=%s, destination=%s, type=%b, code=%b\n",
  176. ipv4_packet.source().to_string().characters(),
  177. ipv4_packet.destination().to_string().characters(),
  178. icmp_header.type(),
  179. icmp_header.code());
  180. #endif
  181. {
  182. LOCKER(IPv4Socket::all_sockets().lock());
  183. for (RefPtr<IPv4Socket> socket : IPv4Socket::all_sockets().resource()) {
  184. LOCKER(socket->lock());
  185. if (socket->protocol() != (unsigned)IPv4Protocol::ICMP)
  186. continue;
  187. socket->did_receive(ipv4_packet.source(), 0, KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
  188. }
  189. }
  190. auto* adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
  191. if (!adapter)
  192. return;
  193. if (icmp_header.type() == ICMPType::EchoRequest) {
  194. auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header);
  195. kprintf("handle_icmp: EchoRequest from %s: id=%u, seq=%u\n",
  196. ipv4_packet.source().to_string().characters(),
  197. (u16)request.identifier,
  198. (u16)request.sequence_number);
  199. size_t icmp_packet_size = ipv4_packet.payload_size();
  200. auto buffer = ByteBuffer::create_zeroed(icmp_packet_size);
  201. auto& response = *(ICMPEchoPacket*)buffer.pointer();
  202. response.header.set_type(ICMPType::EchoReply);
  203. response.header.set_code(0);
  204. response.identifier = request.identifier;
  205. response.sequence_number = request.sequence_number;
  206. if (size_t icmp_payload_size = icmp_packet_size - sizeof(ICMPEchoPacket))
  207. memcpy(response.payload(), request.payload(), icmp_payload_size);
  208. response.header.set_checksum(internet_checksum(&response, icmp_packet_size));
  209. adapter->send_ipv4(eth.source(), ipv4_packet.source(), IPv4Protocol::ICMP, buffer.data(), buffer.size());
  210. }
  211. }
  212. void handle_udp(const EthernetFrameHeader& eth, int frame_size)
  213. {
  214. (void)frame_size;
  215. auto& ipv4_packet = *static_cast<const IPv4Packet*>(eth.payload());
  216. auto* adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
  217. if (!adapter) {
  218. kprintf("handle_udp: this packet is not for me, it's for %s\n", ipv4_packet.destination().to_string().characters());
  219. return;
  220. }
  221. auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
  222. #ifdef UDP_DEBUG
  223. kprintf("handle_udp: source=%s:%u, destination=%s:%u length=%u\n",
  224. ipv4_packet.source().to_string().characters(),
  225. udp_packet.source_port(),
  226. ipv4_packet.destination().to_string().characters(),
  227. udp_packet.destination_port(),
  228. udp_packet.length());
  229. #endif
  230. auto socket = UDPSocket::from_port(udp_packet.destination_port());
  231. if (!socket) {
  232. kprintf("handle_udp: No UDP socket for port %u\n", udp_packet.destination_port());
  233. return;
  234. }
  235. ASSERT(socket->type() == SOCK_DGRAM);
  236. ASSERT(socket->local_port() == udp_packet.destination_port());
  237. socket->did_receive(ipv4_packet.source(), udp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
  238. }
  239. void handle_tcp(const EthernetFrameHeader& eth, int frame_size)
  240. {
  241. (void)frame_size;
  242. auto& ipv4_packet = *static_cast<const IPv4Packet*>(eth.payload());
  243. auto* adapter = NetworkAdapter::from_ipv4_address(ipv4_packet.destination());
  244. if (!adapter) {
  245. kprintf("handle_tcp: this packet is not for me, it's for %s\n", ipv4_packet.destination().to_string().characters());
  246. return;
  247. }
  248. auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
  249. size_t payload_size = ipv4_packet.payload_size() - tcp_packet.header_size();
  250. #ifdef TCP_DEBUG
  251. kprintf("handle_tcp: source=%s:%u, destination=%s:%u seq_no=%u, ack_no=%u, flags=%w (%s %s), window_size=%u, payload_size=%u\n",
  252. ipv4_packet.source().to_string().characters(),
  253. tcp_packet.source_port(),
  254. ipv4_packet.destination().to_string().characters(),
  255. tcp_packet.destination_port(),
  256. tcp_packet.sequence_number(),
  257. tcp_packet.ack_number(),
  258. tcp_packet.flags(),
  259. tcp_packet.has_syn() ? "SYN" : "",
  260. tcp_packet.has_ack() ? "ACK" : "",
  261. tcp_packet.window_size(),
  262. payload_size);
  263. #endif
  264. auto socket = TCPSocket::from_port(tcp_packet.destination_port());
  265. if (!socket) {
  266. kprintf("handle_tcp: No TCP socket for port %u\n", tcp_packet.destination_port());
  267. return;
  268. }
  269. ASSERT(socket->type() == SOCK_STREAM);
  270. ASSERT(socket->local_port() == tcp_packet.destination_port());
  271. if (tcp_packet.ack_number() != socket->sequence_number()) {
  272. kprintf("handle_tcp: ack/seq mismatch: got %u, wanted %u\n", tcp_packet.ack_number(), socket->sequence_number());
  273. return;
  274. }
  275. if (tcp_packet.has_syn() && tcp_packet.has_ack()) {
  276. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  277. socket->send_tcp_packet(TCPFlags::ACK);
  278. socket->set_connected(true);
  279. kprintf("handle_tcp: Connection established!\n");
  280. socket->set_state(TCPSocket::State::Connected);
  281. return;
  282. }
  283. if (tcp_packet.has_fin()) {
  284. kprintf("handle_tcp: Got FIN, payload_size=%u\n", payload_size);
  285. if (payload_size != 0)
  286. socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
  287. socket->set_ack_number(tcp_packet.sequence_number() + payload_size + 1);
  288. socket->send_tcp_packet(TCPFlags::FIN | TCPFlags::ACK);
  289. socket->set_state(TCPSocket::State::Disconnecting);
  290. socket->set_connected(false);
  291. return;
  292. }
  293. socket->set_ack_number(tcp_packet.sequence_number() + payload_size);
  294. #ifdef TCP_DEBUG
  295. kprintf("Got packet with ack_no=%u, seq_no=%u, payload_size=%u, acking it with new ack_no=%u, seq_no=%u\n",
  296. tcp_packet.ack_number(),
  297. tcp_packet.sequence_number(),
  298. payload_size,
  299. socket->ack_number(),
  300. socket->sequence_number());
  301. #endif
  302. socket->send_tcp_packet(TCPFlags::ACK);
  303. if (payload_size != 0)
  304. socket->did_receive(ipv4_packet.source(), tcp_packet.source_port(), KBuffer::copy(&ipv4_packet, sizeof(IPv4Packet) + ipv4_packet.payload_size()));
  305. }