TCPSocket.cpp 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205
  1. #include <Kernel/Net/TCPSocket.h>
  2. #include <Kernel/Net/TCP.h>
  3. #include <Kernel/Net/NetworkAdapter.h>
  4. #include <Kernel/Net/Routing.h>
  5. #include <Kernel/Process.h>
  6. #include <Kernel/Devices/RandomDevice.h>
  7. Lockable<HashMap<word, TCPSocket*>>& TCPSocket::sockets_by_port()
  8. {
  9. static Lockable<HashMap<word, TCPSocket*>>* s_map;
  10. if (!s_map)
  11. s_map = new Lockable<HashMap<word, TCPSocket*>>;
  12. return *s_map;
  13. }
  14. TCPSocketHandle TCPSocket::from_port(word port)
  15. {
  16. RetainPtr<TCPSocket> socket;
  17. {
  18. LOCKER(sockets_by_port().lock());
  19. auto it = sockets_by_port().resource().find(port);
  20. if (it == sockets_by_port().resource().end())
  21. return { };
  22. socket = (*it).value;
  23. ASSERT(socket);
  24. }
  25. return { move(socket) };
  26. }
  27. TCPSocket::TCPSocket(int protocol)
  28. : IPv4Socket(SOCK_STREAM, protocol)
  29. {
  30. }
  31. TCPSocket::~TCPSocket()
  32. {
  33. LOCKER(sockets_by_port().lock());
  34. sockets_by_port().resource().remove(source_port());
  35. }
  36. Retained<TCPSocket> TCPSocket::create(int protocol)
  37. {
  38. return adopt(*new TCPSocket(protocol));
  39. }
  40. int TCPSocket::protocol_receive(const ByteBuffer& packet_buffer, void* buffer, size_t buffer_size, int flags, sockaddr* addr, socklen_t* addr_length)
  41. {
  42. (void)flags;
  43. (void)addr_length;
  44. ASSERT(!packet_buffer.is_null());
  45. auto& ipv4_packet = *(const IPv4Packet*)(packet_buffer.pointer());
  46. auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
  47. size_t payload_size = packet_buffer.size() - sizeof(IPv4Packet) - tcp_packet.header_size();
  48. kprintf("payload_size %u, will it fit in %u?\n", payload_size, buffer_size);
  49. ASSERT(buffer_size >= payload_size);
  50. if (addr) {
  51. auto& ia = *(sockaddr_in*)addr;
  52. ia.sin_port = htons(tcp_packet.destination_port());
  53. }
  54. memcpy(buffer, tcp_packet.payload(), payload_size);
  55. return payload_size;
  56. }
  57. int TCPSocket::protocol_send(const void* data, int data_length)
  58. {
  59. auto* adapter = adapter_for_route_to(destination_address());
  60. if (!adapter)
  61. return -EHOSTUNREACH;
  62. send_tcp_packet(TCPFlags::PUSH | TCPFlags::ACK, data, data_length);
  63. return data_length;
  64. }
  65. void TCPSocket::send_tcp_packet(word flags, const void* payload, int payload_size)
  66. {
  67. // FIXME: Maybe the socket should be bound to an adapter instead of looking it up every time?
  68. auto* adapter = adapter_for_route_to(destination_address());
  69. ASSERT(adapter);
  70. auto buffer = ByteBuffer::create_zeroed(sizeof(TCPPacket) + payload_size);
  71. auto& tcp_packet = *(TCPPacket*)(buffer.pointer());
  72. ASSERT(source_port());
  73. tcp_packet.set_source_port(source_port());
  74. tcp_packet.set_destination_port(destination_port());
  75. tcp_packet.set_window_size(1024);
  76. tcp_packet.set_sequence_number(m_sequence_number);
  77. tcp_packet.set_data_offset(sizeof(TCPPacket) / sizeof(dword));
  78. tcp_packet.set_flags(flags);
  79. if (flags & TCPFlags::ACK)
  80. tcp_packet.set_ack_number(m_ack_number);
  81. if (flags == TCPFlags::SYN) {
  82. ++m_sequence_number;
  83. } else {
  84. m_sequence_number += payload_size;
  85. }
  86. memcpy(tcp_packet.payload(), payload, payload_size);
  87. tcp_packet.set_checksum(compute_tcp_checksum(adapter->ipv4_address(), destination_address(), tcp_packet, payload_size));
  88. kprintf("sending tcp packet from %s:%u to %s:%u with (%s %s) seq_no=%u, ack_no=%u\n",
  89. adapter->ipv4_address().to_string().characters(),
  90. source_port(),
  91. destination_address().to_string().characters(),
  92. destination_port(),
  93. tcp_packet.has_syn() ? "SYN" : "",
  94. tcp_packet.has_ack() ? "ACK" : "",
  95. tcp_packet.sequence_number(),
  96. tcp_packet.ack_number()
  97. );
  98. adapter->send_ipv4(MACAddress(), destination_address(), IPv4Protocol::TCP, move(buffer));
  99. }
  100. NetworkOrdered<word> TCPSocket::compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket& packet, word payload_size)
  101. {
  102. struct [[gnu::packed]] PseudoHeader {
  103. IPv4Address source;
  104. IPv4Address destination;
  105. byte zero;
  106. byte protocol;
  107. NetworkOrdered<word> payload_size;
  108. };
  109. PseudoHeader pseudo_header { source, destination, 0, (byte)IPv4Protocol::TCP, sizeof(TCPPacket) + payload_size };
  110. dword checksum = 0;
  111. auto* w = (const NetworkOrdered<word>*)&pseudo_header;
  112. for (size_t i = 0; i < sizeof(pseudo_header) / sizeof(word); ++i) {
  113. checksum += w[i];
  114. if (checksum > 0xffff)
  115. checksum = (checksum >> 16) + (checksum & 0xffff);
  116. }
  117. w = (const NetworkOrdered<word>*)&packet;
  118. for (size_t i = 0; i < sizeof(packet) / sizeof(word); ++i) {
  119. checksum += w[i];
  120. if (checksum > 0xffff)
  121. checksum = (checksum >> 16) + (checksum & 0xffff);
  122. }
  123. ASSERT(packet.data_offset() * 4 == sizeof(TCPPacket));
  124. w = (const NetworkOrdered<word>*)packet.payload();
  125. for (size_t i = 0; i < payload_size / sizeof(word); ++i) {
  126. checksum += w[i];
  127. if (checksum > 0xffff)
  128. checksum = (checksum >> 16) + (checksum & 0xffff);
  129. }
  130. if (payload_size & 1) {
  131. word expanded_byte = ((const byte*)packet.payload())[payload_size - 1] << 8;
  132. checksum += expanded_byte;
  133. if (checksum > 0xffff)
  134. checksum = (checksum >> 16) + (checksum & 0xffff);
  135. }
  136. return ~(checksum & 0xffff);
  137. }
  138. KResult TCPSocket::protocol_connect(FileDescriptor& descriptor, ShouldBlock should_block)
  139. {
  140. auto* adapter = adapter_for_route_to(destination_address());
  141. if (!adapter)
  142. return KResult(-EHOSTUNREACH);
  143. allocate_source_port_if_needed();
  144. m_sequence_number = 0;
  145. m_ack_number = 0;
  146. send_tcp_packet(TCPFlags::SYN);
  147. m_state = State::Connecting;
  148. if (should_block == ShouldBlock::Yes) {
  149. current->block(Thread::BlockedConnect, descriptor);
  150. ASSERT(is_connected());
  151. return KSuccess;
  152. }
  153. return KResult(-EINPROGRESS);
  154. }
  155. int TCPSocket::protocol_allocate_source_port()
  156. {
  157. static const word first_ephemeral_port = 32768;
  158. static const word last_ephemeral_port = 60999;
  159. static const word ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
  160. word first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
  161. LOCKER(sockets_by_port().lock());
  162. for (word port = first_scan_port;;) {
  163. auto it = sockets_by_port().resource().find(port);
  164. if (it == sockets_by_port().resource().end()) {
  165. set_source_port(port);
  166. sockets_by_port().resource().set(port, this);
  167. return port;
  168. }
  169. ++port;
  170. if (port > last_ephemeral_port)
  171. port = first_ephemeral_port;
  172. if (port == first_scan_port)
  173. break;
  174. }
  175. return -EADDRINUSE;
  176. }
  177. bool TCPSocket::protocol_is_disconnected() const
  178. {
  179. return m_state == State::Disconnecting || m_state == State::Disconnected;
  180. }