1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 16:47:36 +00:00

AK: Rename the common integer typedefs to make it obvious what they are.

These types can be picked up by including <AK/Types.h>:

* u8, u16, u32, u64 (unsigned)
* i8, i16, i32, i64 (signed)
This commit is contained in:
Andreas Kling 2019-07-03 21:17:35 +02:00
parent c4c4bbc5ba
commit 27f699ef0c
208 changed files with 1603 additions and 1621 deletions

View file

@ -6,14 +6,14 @@
#include <Kernel/Net/MACAddress.h>
struct ARPOperation {
enum : word {
enum : u16 {
Request = 1,
Response = 2,
};
};
struct ARPHardwareType {
enum : word {
enum : u16 {
Ethernet = 1,
};
};
@ -21,20 +21,20 @@ struct ARPHardwareType {
class [[gnu::packed]] ARPPacket
{
public:
word hardware_type() const { return m_hardware_type; }
void set_hardware_type(word w) { m_hardware_type = w; }
u16 hardware_type() const { return m_hardware_type; }
void set_hardware_type(u16 w) { m_hardware_type = w; }
word protocol_type() const { return m_protocol_type; }
void set_protocol_type(word w) { m_protocol_type = w; }
u16 protocol_type() const { return m_protocol_type; }
void set_protocol_type(u16 w) { m_protocol_type = w; }
byte hardware_address_length() const { return m_hardware_address_length; }
void set_hardware_address_length(byte b) { m_hardware_address_length = b; }
u8 hardware_address_length() const { return m_hardware_address_length; }
void set_hardware_address_length(u8 b) { m_hardware_address_length = b; }
byte protocol_address_length() const { return m_protocol_address_length; }
void set_protocol_address_length(byte b) { m_protocol_address_length = b; }
u8 protocol_address_length() const { return m_protocol_address_length; }
void set_protocol_address_length(u8 b) { m_protocol_address_length = b; }
word operation() const { return m_operation; }
void set_operation(word w) { m_operation = w; }
u16 operation() const { return m_operation; }
void set_operation(u16 w) { m_operation = w; }
const MACAddress& sender_hardware_address() const { return m_sender_hardware_address; }
void set_sender_hardware_address(const MACAddress& address) { m_sender_hardware_address = address; }
@ -49,11 +49,11 @@ public:
void set_target_protocol_address(const IPv4Address& address) { m_target_protocol_address = address; }
private:
NetworkOrdered<word> m_hardware_type { ARPHardwareType::Ethernet };
NetworkOrdered<word> m_protocol_type { EtherType::IPv4 };
byte m_hardware_address_length { sizeof(MACAddress) };
byte m_protocol_address_length { sizeof(IPv4Address) };
NetworkOrdered<word> m_operation;
NetworkOrdered<u16> m_hardware_type { ARPHardwareType::Ethernet };
NetworkOrdered<u16> m_protocol_type { EtherType::IPv4 };
u8 m_hardware_address_length { sizeof(MACAddress) };
u8 m_protocol_address_length { sizeof(IPv4Address) };
NetworkOrdered<u16> m_operation;
MACAddress m_sender_hardware_address;
IPv4Address m_sender_protocol_address;
MACAddress m_target_hardware_address;

View file

@ -92,7 +92,7 @@ OwnPtr<E1000NetworkAdapter> E1000NetworkAdapter::autodetect()
});
if (found_address.is_null())
return nullptr;
byte irq = PCI::get_interrupt_line(found_address);
u8 irq = PCI::get_interrupt_line(found_address);
return make<E1000NetworkAdapter>(found_address, irq);
}
@ -102,7 +102,7 @@ E1000NetworkAdapter* E1000NetworkAdapter::the()
return s_the;
}
E1000NetworkAdapter::E1000NetworkAdapter(PCI::Address pci_address, byte irq)
E1000NetworkAdapter::E1000NetworkAdapter(PCI::Address pci_address, u8 irq)
: IRQHandler(irq)
, m_pci_address(pci_address)
{
@ -132,7 +132,7 @@ E1000NetworkAdapter::E1000NetworkAdapter(PCI::Address pci_address, byte irq)
const auto& mac = mac_address();
kprintf("E1000: MAC address: %b:%b:%b:%b:%b:%b\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
dword flags = in32(REG_CTRL);
u32 flags = in32(REG_CTRL);
out32(REG_CTRL, flags | ECTRL_SLU);
initialize_rx_descriptors();
@ -153,9 +153,9 @@ void E1000NetworkAdapter::handle_irq()
{
out32(REG_IMASK, 0x1);
dword status = in32(0xc0);
u32 status = in32(0xc0);
if (status & 4) {
dword flags = in32(REG_CTRL);
u32 flags = in32(REG_CTRL);
out32(REG_CTRL, flags | ECTRL_SLU);
}
if (status & 0x10) {
@ -170,7 +170,7 @@ void E1000NetworkAdapter::detect_eeprom()
{
out32(REG_EEPROM, 0x1);
for (volatile int i = 0; i < 999; ++i) {
dword data = in32(REG_EEPROM);
u32 data = in32(REG_EEPROM);
if (data & 0x10) {
m_has_eeprom = true;
return;
@ -179,16 +179,16 @@ void E1000NetworkAdapter::detect_eeprom()
m_has_eeprom = false;
}
dword E1000NetworkAdapter::read_eeprom(byte address)
u32 E1000NetworkAdapter::read_eeprom(u8 address)
{
word data = 0;
dword tmp = 0;
u16 data = 0;
u32 tmp = 0;
if (m_has_eeprom) {
out32(REG_EEPROM, ((dword)address << 8) | 1);
out32(REG_EEPROM, ((u32)address << 8) | 1);
while (!((tmp = in32(REG_EEPROM)) & (1 << 4)))
;
} else {
out32(REG_EEPROM, ((dword)address << 2) | 1);
out32(REG_EEPROM, ((u32)address << 2) | 1);
while (!((tmp = in32(REG_EEPROM)) & (1 << 1)))
;
}
@ -199,8 +199,8 @@ dword E1000NetworkAdapter::read_eeprom(byte address)
void E1000NetworkAdapter::read_mac_address()
{
if (m_has_eeprom) {
byte mac[6];
dword tmp = read_eeprom(0);
u8 mac[6];
u32 tmp = read_eeprom(0);
mac[0] = tmp & 0xff;
mac[1] = tmp >> 8;
tmp = read_eeprom(1);
@ -217,14 +217,14 @@ void E1000NetworkAdapter::read_mac_address()
void E1000NetworkAdapter::initialize_rx_descriptors()
{
auto ptr = (dword)kmalloc_eternal(sizeof(e1000_rx_desc) * number_of_rx_descriptors + 16);
auto ptr = (u32)kmalloc_eternal(sizeof(e1000_rx_desc) * number_of_rx_descriptors + 16);
// Make sure it's 16-byte aligned.
if (ptr % 16)
ptr = (ptr + 16) - (ptr % 16);
m_rx_descriptors = (e1000_rx_desc*)ptr;
for (int i = 0; i < number_of_rx_descriptors; ++i) {
auto& descriptor = m_rx_descriptors[i];
descriptor.addr = (qword)kmalloc_eternal(8192 + 16);
descriptor.addr = (u64)kmalloc_eternal(8192 + 16);
descriptor.status = 0;
}
@ -239,14 +239,14 @@ void E1000NetworkAdapter::initialize_rx_descriptors()
void E1000NetworkAdapter::initialize_tx_descriptors()
{
auto ptr = (dword)kmalloc_eternal(sizeof(e1000_tx_desc) * number_of_tx_descriptors + 16);
auto ptr = (u32)kmalloc_eternal(sizeof(e1000_tx_desc) * number_of_tx_descriptors + 16);
// Make sure it's 16-byte aligned.
if (ptr % 16)
ptr = (ptr + 16) - (ptr % 16);
m_tx_descriptors = (e1000_tx_desc*)ptr;
for (int i = 0; i < number_of_tx_descriptors; ++i) {
auto& descriptor = m_tx_descriptors[i];
descriptor.addr = (qword)kmalloc_eternal(8192 + 16);
descriptor.addr = (u64)kmalloc_eternal(8192 + 16);
descriptor.cmd = 0;
}
@ -260,60 +260,60 @@ void E1000NetworkAdapter::initialize_tx_descriptors()
out32(REG_TIPG, 0x0060200A);
}
void E1000NetworkAdapter::out8(word address, byte data)
void E1000NetworkAdapter::out8(u16 address, u8 data)
{
if (m_use_mmio) {
auto* ptr = (volatile byte*)(m_mmio_base.get() + address);
auto* ptr = (volatile u8*)(m_mmio_base.get() + address);
*ptr = data;
return;
}
IO::out8(m_io_base + address, data);
}
void E1000NetworkAdapter::out16(word address, word data)
void E1000NetworkAdapter::out16(u16 address, u16 data)
{
if (m_use_mmio) {
auto* ptr = (volatile word*)(m_mmio_base.get() + address);
auto* ptr = (volatile u16*)(m_mmio_base.get() + address);
*ptr = data;
return;
}
IO::out16(m_io_base + address, data);
}
void E1000NetworkAdapter::out32(word address, dword data)
void E1000NetworkAdapter::out32(u16 address, u32 data)
{
if (m_use_mmio) {
auto* ptr = (volatile dword*)(m_mmio_base.get() + address);
auto* ptr = (volatile u32*)(m_mmio_base.get() + address);
*ptr = data;
return;
}
IO::out32(m_io_base + address, data);
}
byte E1000NetworkAdapter::in8(word address)
u8 E1000NetworkAdapter::in8(u16 address)
{
if (m_use_mmio)
return *(volatile byte*)(m_mmio_base.get() + address);
return *(volatile u8*)(m_mmio_base.get() + address);
return IO::in8(m_io_base + address);
}
word E1000NetworkAdapter::in16(word address)
u16 E1000NetworkAdapter::in16(u16 address)
{
if (m_use_mmio)
return *(volatile word*)(m_mmio_base.get() + address);
return *(volatile u16*)(m_mmio_base.get() + address);
return IO::in16(m_io_base + address);
}
dword E1000NetworkAdapter::in32(word address)
u32 E1000NetworkAdapter::in32(u16 address)
{
if (m_use_mmio)
return *(volatile dword*)(m_mmio_base.get() + address);
return *(volatile u32*)(m_mmio_base.get() + address);
return IO::in32(m_io_base + address);
}
void E1000NetworkAdapter::send_raw(const byte* data, int length)
void E1000NetworkAdapter::send_raw(const u8* data, int length)
{
dword tx_current = in32(REG_TXDESCTAIL);
u32 tx_current = in32(REG_TXDESCTAIL);
#ifdef E1000_DEBUG
kprintf("E1000: Sending packet (%d bytes)\n", length);
#endif
@ -337,7 +337,7 @@ void E1000NetworkAdapter::send_raw(const byte* data, int length)
void E1000NetworkAdapter::receive()
{
dword rx_current;
u32 rx_current;
for (;;) {
rx_current = in32(REG_RXDESCTAIL);
if (rx_current == in32(REG_RXDESCHEAD))
@ -345,8 +345,8 @@ void E1000NetworkAdapter::receive()
rx_current = (rx_current + 1) % number_of_rx_descriptors;
if (!(m_rx_descriptors[rx_current].status & 1))
break;
auto* buffer = (byte*)m_rx_descriptors[rx_current].addr;
word length = m_rx_descriptors[rx_current].length;
auto* buffer = (u8*)m_rx_descriptors[rx_current].addr;
u16 length = m_rx_descriptors[rx_current].length;
#ifdef E1000_DEBUG
kprintf("E1000: Received 1 packet @ %p (%u) bytes!\n", buffer, length);
#endif

View file

@ -13,10 +13,10 @@ public:
static OwnPtr<E1000NetworkAdapter> autodetect();
E1000NetworkAdapter(PCI::Address, byte irq);
E1000NetworkAdapter(PCI::Address, u8 irq);
virtual ~E1000NetworkAdapter() override;
virtual void send_raw(const byte*, int) override;
virtual void send_raw(const u8*, int) override;
private:
virtual void handle_irq() override;
@ -44,28 +44,28 @@ private:
};
void detect_eeprom();
dword read_eeprom(byte address);
u32 read_eeprom(u8 address);
void read_mac_address();
void write_command(word address, dword);
dword read_command(word address);
void write_command(u16 address, u32);
u32 read_command(u16 address);
void initialize_rx_descriptors();
void initialize_tx_descriptors();
void out8(word address, byte);
void out16(word address, word);
void out32(word address, dword);
byte in8(word address);
word in16(word address);
dword in32(word address);
void out8(u16 address, u8);
void out16(u16 address, u16);
void out32(u16 address, u32);
u8 in8(u16 address);
u16 in16(u16 address);
u32 in32(u16 address);
void receive();
PCI::Address m_pci_address;
word m_io_base { 0 };
u16 m_io_base { 0 };
PhysicalAddress m_mmio_base;
byte m_interrupt_line { 0 };
u8 m_interrupt_line { 0 };
bool m_has_eeprom { false };
bool m_use_mmio { false };

View file

@ -3,7 +3,7 @@
#include <AK/Types.h>
struct EtherType {
enum : word {
enum : u16 {
ARP = 0x0806,
IPv4 = 0x0800,
};

View file

@ -15,8 +15,8 @@ public:
MACAddress source() const { return m_source; }
void set_source(const MACAddress& address) { m_source = address; }
word ether_type() const { return m_ether_type; }
void set_ether_type(word ether_type) { m_ether_type = ether_type; }
u16 ether_type() const { return m_ether_type; }
void set_ether_type(u16 ether_type) { m_ether_type = ether_type; }
const void* payload() const { return &m_payload[0]; }
void* payload() { return &m_payload[0]; }
@ -24,8 +24,8 @@ public:
private:
MACAddress m_destination;
MACAddress m_source;
NetworkOrdered<word> m_ether_type;
dword m_payload[0];
NetworkOrdered<u16> m_ether_type;
u32 m_payload[0];
};
static_assert(sizeof(EthernetFrameHeader) == 14);

View file

@ -16,22 +16,22 @@ public:
ICMPHeader() {}
~ICMPHeader() {}
byte type() const { return m_type; }
void set_type(byte b) { m_type = b; }
u8 type() const { return m_type; }
void set_type(u8 b) { m_type = b; }
byte code() const { return m_code; }
void set_code(byte b) { m_code = b; }
u8 code() const { return m_code; }
void set_code(u8 b) { m_code = b; }
word checksum() const { return m_checksum; }
void set_checksum(word w) { m_checksum = w; }
u16 checksum() const { return m_checksum; }
void set_checksum(u16 w) { m_checksum = w; }
const void* payload() const { return this + 1; }
void* payload() { return this + 1; }
private:
byte m_type { 0 };
byte m_code { 0 };
NetworkOrdered<word> m_checksum { 0 };
u8 m_type { 0 };
u8 m_code { 0 };
NetworkOrdered<u16> m_checksum { 0 };
// NOTE: The rest of the header is 4 bytes
};
@ -40,8 +40,8 @@ static_assert(sizeof(ICMPHeader) == 4);
struct [[gnu::packed]] ICMPEchoPacket
{
ICMPHeader header;
NetworkOrdered<word> identifier;
NetworkOrdered<word> sequence_number;
NetworkOrdered<u16> identifier;
NetworkOrdered<u16> sequence_number;
void* payload() { return this + 1; }
const void* payload() const { return this + 1; }
};

View file

@ -6,37 +6,37 @@
#include <AK/NetworkOrdered.h>
#include <AK/Types.h>
enum class IPv4Protocol : word {
enum class IPv4Protocol : u16 {
ICMP = 1,
TCP = 6,
UDP = 17,
};
NetworkOrdered<word> internet_checksum(const void*, size_t);
NetworkOrdered<u16> internet_checksum(const void*, size_t);
class [[gnu::packed]] IPv4Packet
{
public:
byte version() const { return (m_version_and_ihl >> 4) & 0xf; }
void set_version(byte version) { m_version_and_ihl = (m_version_and_ihl & 0x0f) | (version << 4); }
u8 version() const { return (m_version_and_ihl >> 4) & 0xf; }
void set_version(u8 version) { m_version_and_ihl = (m_version_and_ihl & 0x0f) | (version << 4); }
byte internet_header_length() const { return m_version_and_ihl & 0xf; }
void set_internet_header_length(byte ihl) { m_version_and_ihl = (m_version_and_ihl & 0xf0) | (ihl & 0x0f); }
u8 internet_header_length() const { return m_version_and_ihl & 0xf; }
void set_internet_header_length(u8 ihl) { m_version_and_ihl = (m_version_and_ihl & 0xf0) | (ihl & 0x0f); }
word length() const { return m_length; }
void set_length(word length) { m_length = length; }
u16 length() const { return m_length; }
void set_length(u16 length) { m_length = length; }
word ident() const { return m_ident; }
void set_ident(word ident) { m_ident = ident; }
u16 ident() const { return m_ident; }
void set_ident(u16 ident) { m_ident = ident; }
byte ttl() const { return m_ttl; }
void set_ttl(byte ttl) { m_ttl = ttl; }
u8 ttl() const { return m_ttl; }
void set_ttl(u8 ttl) { m_ttl = ttl; }
byte protocol() const { return m_protocol; }
void set_protocol(byte protocol) { m_protocol = protocol; }
u8 protocol() const { return m_protocol; }
void set_protocol(u8 protocol) { m_protocol = protocol; }
word checksum() const { return m_checksum; }
void set_checksum(word checksum) { m_checksum = checksum; }
u16 checksum() const { return m_checksum; }
void set_checksum(u16 checksum) { m_checksum = checksum; }
const IPv4Address& source() const { return m_source; }
void set_source(const IPv4Address& address) { m_source = address; }
@ -47,33 +47,33 @@ public:
void* payload() { return this + 1; }
const void* payload() const { return this + 1; }
word payload_size() const { return m_length - sizeof(IPv4Packet); }
u16 payload_size() const { return m_length - sizeof(IPv4Packet); }
NetworkOrdered<word> compute_checksum() const
NetworkOrdered<u16> compute_checksum() const
{
ASSERT(!m_checksum);
return internet_checksum(this, sizeof(IPv4Packet));
}
private:
byte m_version_and_ihl { 0 };
byte m_dscp_and_ecn { 0 };
NetworkOrdered<word> m_length;
NetworkOrdered<word> m_ident;
NetworkOrdered<word> m_flags_and_fragment;
byte m_ttl { 0 };
NetworkOrdered<byte> m_protocol;
NetworkOrdered<word> m_checksum;
u8 m_version_and_ihl { 0 };
u8 m_dscp_and_ecn { 0 };
NetworkOrdered<u16> m_length;
NetworkOrdered<u16> m_ident;
NetworkOrdered<u16> m_flags_and_fragment;
u8 m_ttl { 0 };
NetworkOrdered<u8> m_protocol;
NetworkOrdered<u16> m_checksum;
IPv4Address m_source;
IPv4Address m_destination;
};
static_assert(sizeof(IPv4Packet) == 20);
inline NetworkOrdered<word> internet_checksum(const void* ptr, size_t count)
inline NetworkOrdered<u16> internet_checksum(const void* ptr, size_t count)
{
dword checksum = 0;
auto* w = (const word*)ptr;
u32 checksum = 0;
auto* w = (const u16*)ptr;
while (count > 1) {
checksum += convert_between_host_and_network(*w++);
if (checksum & 0x80000000)

View file

@ -81,7 +81,7 @@ KResult IPv4Socket::bind(const sockaddr* address, socklen_t address_size)
return KResult(-EINVAL);
auto& ia = *(const sockaddr_in*)address;
m_local_address = IPv4Address((const byte*)&ia.sin_addr.s_addr);
m_local_address = IPv4Address((const u8*)&ia.sin_addr.s_addr);
m_local_port = ntohs(ia.sin_port);
dbgprintf("IPv4Socket::bind %s{%p} to port %u\n", class_name(), this, m_local_port);
@ -98,7 +98,7 @@ KResult IPv4Socket::connect(FileDescription& description, const sockaddr* addres
return KResult(-EINVAL);
auto& ia = *(const sockaddr_in*)address;
m_peer_address = IPv4Address((const byte*)&ia.sin_addr.s_addr);
m_peer_address = IPv4Address((const u8*)&ia.sin_addr.s_addr);
m_peer_port = ntohs(ia.sin_port);
return protocol_connect(description, should_block);
@ -123,12 +123,12 @@ bool IPv4Socket::can_read(FileDescription& description) const
return m_can_read;
}
ssize_t IPv4Socket::read(FileDescription& description, byte* buffer, ssize_t size)
ssize_t IPv4Socket::read(FileDescription& description, u8* buffer, ssize_t size)
{
return recvfrom(description, buffer, size, 0, nullptr, 0);
}
ssize_t IPv4Socket::write(FileDescription& description, const byte* data, ssize_t size)
ssize_t IPv4Socket::write(FileDescription& description, const u8* data, ssize_t size)
{
return sendto(description, data, size, 0, nullptr, 0);
}
@ -145,7 +145,7 @@ int IPv4Socket::allocate_local_port_if_needed()
int port = protocol_allocate_local_port();
if (port < 0)
return port;
m_local_port = (word)port;
m_local_port = (u16)port;
return port;
}
@ -162,7 +162,7 @@ ssize_t IPv4Socket::sendto(FileDescription&, const void* data, size_t data_lengt
}
auto& ia = *(const sockaddr_in*)addr;
m_peer_address = IPv4Address((const byte*)&ia.sin_addr.s_addr);
m_peer_address = IPv4Address((const u8*)&ia.sin_addr.s_addr);
m_peer_port = ntohs(ia.sin_port);
}
@ -249,7 +249,7 @@ ssize_t IPv4Socket::recvfrom(FileDescription& description, void* buffer, size_t
return protocol_receive(packet.data, buffer, buffer_length, flags);
}
void IPv4Socket::did_receive(const IPv4Address& source_address, word source_port, ByteBuffer&& packet)
void IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port, ByteBuffer&& packet)
{
LOCKER(lock());
auto packet_size = packet.size();

View file

@ -27,21 +27,21 @@ public:
virtual void attach(FileDescription&) override;
virtual void detach(FileDescription&) override;
virtual bool can_read(FileDescription&) const override;
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual bool can_write(FileDescription&) const override;
virtual ssize_t sendto(FileDescription&, const void*, size_t, int, const sockaddr*, socklen_t) override;
virtual ssize_t recvfrom(FileDescription&, void*, size_t, int flags, sockaddr*, socklen_t*) override;
void did_receive(const IPv4Address& peer_address, word peer_port, ByteBuffer&&);
void did_receive(const IPv4Address& peer_address, u16 peer_port, ByteBuffer&&);
const IPv4Address& local_address() const;
word local_port() const { return m_local_port; }
void set_local_port(word port) { m_local_port = port; }
u16 local_port() const { return m_local_port; }
void set_local_port(u16 port) { m_local_port = port; }
const IPv4Address& peer_address() const { return m_peer_address; }
word peer_port() const { return m_peer_port; }
void set_peer_port(word port) { m_peer_port = port; }
u16 peer_port() const { return m_peer_port; }
void set_peer_port(u16 port) { m_peer_port = port; }
protected:
IPv4Socket(int type, int protocol);
@ -70,16 +70,16 @@ private:
struct ReceivedPacket {
IPv4Address peer_address;
word peer_port;
u16 peer_port;
ByteBuffer data;
};
SinglyLinkedList<ReceivedPacket> m_receive_queue;
word m_local_port { 0 };
word m_peer_port { 0 };
u16 m_local_port { 0 };
u16 m_peer_port { 0 };
dword m_bytes_received { 0 };
u32 m_bytes_received { 0 };
bool m_can_read { false };
};

View file

@ -155,7 +155,7 @@ bool LocalSocket::can_read(FileDescription& description) const
ASSERT_NOT_REACHED();
}
ssize_t LocalSocket::read(FileDescription& description, byte* buffer, ssize_t size)
ssize_t LocalSocket::read(FileDescription& description, u8* buffer, ssize_t size)
{
auto role = description.socket_role();
if (role == SocketRole::Accepted) {
@ -184,7 +184,7 @@ bool LocalSocket::has_attached_peer(const FileDescription& description) const
ASSERT_NOT_REACHED();
}
ssize_t LocalSocket::write(FileDescription& description, const byte* data, ssize_t size)
ssize_t LocalSocket::write(FileDescription& description, const u8* data, ssize_t size)
{
if (!has_attached_peer(description))
return -EPIPE;
@ -206,10 +206,10 @@ bool LocalSocket::can_write(FileDescription& description) const
ssize_t LocalSocket::sendto(FileDescription& description, const void* data, size_t data_size, int, const sockaddr*, socklen_t)
{
return write(description, (const byte*)data, data_size);
return write(description, (const u8*)data, data_size);
}
ssize_t LocalSocket::recvfrom(FileDescription& description, void* buffer, size_t buffer_size, int, sockaddr*, socklen_t*)
{
return read(description, (byte*)buffer, buffer_size);
return read(description, (u8*)buffer, buffer_size);
}

View file

@ -17,8 +17,8 @@ public:
virtual void attach(FileDescription&) override;
virtual void detach(FileDescription&) override;
virtual bool can_read(FileDescription&) const override;
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual bool can_write(FileDescription&) const override;
virtual ssize_t sendto(FileDescription&, const void*, size_t, int, const sockaddr*, socklen_t) override;
virtual ssize_t recvfrom(FileDescription&, void*, size_t, int flags, sockaddr*, socklen_t*) override;

View file

@ -18,7 +18,7 @@ LoopbackAdapter::~LoopbackAdapter()
{
}
void LoopbackAdapter::send_raw(const byte* data, int size)
void LoopbackAdapter::send_raw(const u8* data, int size)
{
dbgprintf("LoopbackAdapter: Sending %d byte(s) to myself.\n", size);
did_receive(data, size);

View file

@ -9,7 +9,7 @@ public:
virtual ~LoopbackAdapter() override;
virtual void send_raw(const byte*, int) override;
virtual void send_raw(const u8*, int) override;
virtual const char* class_name() const override { return "LoopbackAdapter"; }
private:

View file

@ -9,13 +9,13 @@ class [[gnu::packed]] MACAddress
{
public:
MACAddress() {}
MACAddress(const byte data[6])
MACAddress(const u8 data[6])
{
memcpy(m_data, data, 6);
}
~MACAddress() {}
byte operator[](int i) const
u8 operator[](int i) const
{
ASSERT(i >= 0 && i < 6);
return m_data[i];
@ -32,7 +32,7 @@ public:
}
private:
byte m_data[6];
u8 m_data[6];
};
static_assert(sizeof(MACAddress) == 6);

View file

@ -53,7 +53,7 @@ void NetworkAdapter::send(const MACAddress& destination, const ARPPacket& packet
eth->set_destination(destination);
eth->set_ether_type(EtherType::ARP);
memcpy(eth->payload(), &packet, sizeof(ARPPacket));
send_raw((byte*)eth, size_in_bytes);
send_raw((u8*)eth, size_in_bytes);
}
void NetworkAdapter::send_ipv4(const MACAddress& destination_mac, const IPv4Address& destination_ipv4, IPv4Protocol protocol, ByteBuffer&& payload)
@ -69,16 +69,16 @@ void NetworkAdapter::send_ipv4(const MACAddress& destination_mac, const IPv4Addr
ipv4.set_internet_header_length(5);
ipv4.set_source(ipv4_address());
ipv4.set_destination(destination_ipv4);
ipv4.set_protocol((byte)protocol);
ipv4.set_protocol((u8)protocol);
ipv4.set_length(sizeof(IPv4Packet) + payload.size());
ipv4.set_ident(1);
ipv4.set_ttl(64);
ipv4.set_checksum(ipv4.compute_checksum());
memcpy(ipv4.payload(), payload.pointer(), payload.size());
send_raw((const byte*)&eth, size_in_bytes);
send_raw((const u8*)&eth, size_in_bytes);
}
void NetworkAdapter::did_receive(const byte* data, int length)
void NetworkAdapter::did_receive(const u8* data, int length)
{
InterruptDisabler disabler;
m_packet_queue.append(ByteBuffer::copy(data, length));

View file

@ -52,8 +52,8 @@ protected:
NetworkAdapter();
void set_interface_name(const StringView& basename);
void set_mac_address(const MACAddress& mac_address) { m_mac_address = mac_address; }
virtual void send_raw(const byte*, int) = 0;
void did_receive(const byte*, int);
virtual void send_raw(const u8*, int) = 0;
void did_receive(const u8*, int);
private:
MACAddress m_mac_address;

View file

@ -225,8 +225,8 @@ void handle_icmp(const EthernetFrameHeader& eth, int frame_size)
auto& request = reinterpret_cast<const ICMPEchoPacket&>(icmp_header);
kprintf("handle_icmp: EchoRequest from %s: id=%u, seq=%u\n",
ipv4_packet.source().to_string().characters(),
(word)request.identifier,
(word)request.sequence_number);
(u16)request.identifier,
(u16)request.sequence_number);
size_t icmp_packet_size = ipv4_packet.payload_size();
auto buffer = ByteBuffer::create_zeroed(icmp_packet_size);
auto& response = *(ICMPEchoPacket*)buffer.pointer();

View file

@ -9,7 +9,7 @@
#include <Kernel/Lock.h>
#include <Kernel/UnixTypes.h>
enum class SocketRole : byte {
enum class SocketRole : u8 {
None,
Listener,
Accepted,

View file

@ -3,7 +3,7 @@
#include <Kernel/Net/IPv4.h>
struct TCPFlags {
enum : word {
enum : u16 {
FIN = 0x01,
SYN = 0x02,
RST = 0x04,
@ -19,52 +19,52 @@ public:
TCPPacket() {}
~TCPPacket() {}
size_t header_size() const { return data_offset() * sizeof(dword); }
size_t header_size() const { return data_offset() * sizeof(u32); }
word source_port() const { return m_source_port; }
void set_source_port(word port) { m_source_port = port; }
u16 source_port() const { return m_source_port; }
void set_source_port(u16 port) { m_source_port = port; }
word destination_port() const { return m_destination_port; }
void set_destination_port(word port) { m_destination_port = port; }
u16 destination_port() const { return m_destination_port; }
void set_destination_port(u16 port) { m_destination_port = port; }
dword sequence_number() const { return m_sequence_number; }
void set_sequence_number(dword number) { m_sequence_number = number; }
u32 sequence_number() const { return m_sequence_number; }
void set_sequence_number(u32 number) { m_sequence_number = number; }
dword ack_number() const { return m_ack_number; }
void set_ack_number(dword number) { m_ack_number = number; }
u32 ack_number() const { return m_ack_number; }
void set_ack_number(u32 number) { m_ack_number = number; }
word flags() const { return m_flags_and_data_offset & 0x1ff; }
void set_flags(word flags) { m_flags_and_data_offset = (m_flags_and_data_offset & ~0x1ff) | (flags & 0x1ff); }
u16 flags() const { return m_flags_and_data_offset & 0x1ff; }
void set_flags(u16 flags) { m_flags_and_data_offset = (m_flags_and_data_offset & ~0x1ff) | (flags & 0x1ff); }
bool has_syn() const { return flags() & TCPFlags::SYN; }
bool has_ack() const { return flags() & TCPFlags::ACK; }
bool has_fin() const { return flags() & TCPFlags::FIN; }
byte data_offset() const { return (m_flags_and_data_offset & 0xf000) >> 12; }
void set_data_offset(word data_offset) { m_flags_and_data_offset = (m_flags_and_data_offset & ~0xf000) | data_offset << 12; }
u8 data_offset() const { return (m_flags_and_data_offset & 0xf000) >> 12; }
void set_data_offset(u16 data_offset) { m_flags_and_data_offset = (m_flags_and_data_offset & ~0xf000) | data_offset << 12; }
word window_size() const { return m_window_size; }
void set_window_size(word window_size) { m_window_size = window_size; }
u16 window_size() const { return m_window_size; }
void set_window_size(u16 window_size) { m_window_size = window_size; }
word checksum() const { return m_checksum; }
void set_checksum(word checksum) { m_checksum = checksum; }
u16 checksum() const { return m_checksum; }
void set_checksum(u16 checksum) { m_checksum = checksum; }
word urgent() const { return m_urgent; }
void set_urgent(word urgent) { m_urgent = urgent; }
u16 urgent() const { return m_urgent; }
void set_urgent(u16 urgent) { m_urgent = urgent; }
const void* payload() const { return ((const byte*)this) + header_size(); }
void* payload() { return ((byte*)this) + header_size(); }
const void* payload() const { return ((const u8*)this) + header_size(); }
void* payload() { return ((u8*)this) + header_size(); }
private:
NetworkOrdered<word> m_source_port;
NetworkOrdered<word> m_destination_port;
NetworkOrdered<dword> m_sequence_number;
NetworkOrdered<dword> m_ack_number;
NetworkOrdered<u16> m_source_port;
NetworkOrdered<u16> m_destination_port;
NetworkOrdered<u32> m_sequence_number;
NetworkOrdered<u32> m_ack_number;
NetworkOrdered<word> m_flags_and_data_offset;
NetworkOrdered<word> m_window_size;
NetworkOrdered<word> m_checksum;
NetworkOrdered<word> m_urgent;
NetworkOrdered<u16> m_flags_and_data_offset;
NetworkOrdered<u16> m_window_size;
NetworkOrdered<u16> m_checksum;
NetworkOrdered<u16> m_urgent;
};
static_assert(sizeof(TCPPacket) == 20);

View file

@ -5,15 +5,15 @@
#include <Kernel/Net/TCPSocket.h>
#include <Kernel/Process.h>
Lockable<HashMap<word, TCPSocket*>>& TCPSocket::sockets_by_port()
Lockable<HashMap<u16, TCPSocket*>>& TCPSocket::sockets_by_port()
{
static Lockable<HashMap<word, TCPSocket*>>* s_map;
static Lockable<HashMap<u16, TCPSocket*>>* s_map;
if (!s_map)
s_map = new Lockable<HashMap<word, TCPSocket*>>;
s_map = new Lockable<HashMap<u16, TCPSocket*>>;
return *s_map;
}
TCPSocketHandle TCPSocket::from_port(word port)
TCPSocketHandle TCPSocket::from_port(u16 port)
{
RefPtr<TCPSocket> socket;
{
@ -65,7 +65,7 @@ int TCPSocket::protocol_send(const void* data, int data_length)
return data_length;
}
void TCPSocket::send_tcp_packet(word flags, const void* payload, int payload_size)
void TCPSocket::send_tcp_packet(u16 flags, const void* payload, int payload_size)
{
// FIXME: Maybe the socket should be bound to an adapter instead of looking it up every time?
auto* adapter = adapter_for_route_to(peer_address());
@ -78,7 +78,7 @@ void TCPSocket::send_tcp_packet(word flags, const void* payload, int payload_siz
tcp_packet.set_destination_port(peer_port());
tcp_packet.set_window_size(1024);
tcp_packet.set_sequence_number(m_sequence_number);
tcp_packet.set_data_offset(sizeof(TCPPacket) / sizeof(dword));
tcp_packet.set_data_offset(sizeof(TCPPacket) / sizeof(u32));
tcp_packet.set_flags(flags);
if (flags & TCPFlags::ACK)
@ -104,41 +104,41 @@ void TCPSocket::send_tcp_packet(word flags, const void* payload, int payload_siz
adapter->send_ipv4(MACAddress(), peer_address(), IPv4Protocol::TCP, move(buffer));
}
NetworkOrdered<word> TCPSocket::compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket& packet, word payload_size)
NetworkOrdered<u16> TCPSocket::compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket& packet, u16 payload_size)
{
struct [[gnu::packed]] PseudoHeader
{
IPv4Address source;
IPv4Address destination;
byte zero;
byte protocol;
NetworkOrdered<word> payload_size;
u8 zero;
u8 protocol;
NetworkOrdered<u16> payload_size;
};
PseudoHeader pseudo_header { source, destination, 0, (byte)IPv4Protocol::TCP, sizeof(TCPPacket) + payload_size };
PseudoHeader pseudo_header { source, destination, 0, (u8)IPv4Protocol::TCP, sizeof(TCPPacket) + payload_size };
dword checksum = 0;
auto* w = (const NetworkOrdered<word>*)&pseudo_header;
for (size_t i = 0; i < sizeof(pseudo_header) / sizeof(word); ++i) {
u32 checksum = 0;
auto* w = (const NetworkOrdered<u16>*)&pseudo_header;
for (size_t i = 0; i < sizeof(pseudo_header) / sizeof(u16); ++i) {
checksum += w[i];
if (checksum > 0xffff)
checksum = (checksum >> 16) + (checksum & 0xffff);
}
w = (const NetworkOrdered<word>*)&packet;
for (size_t i = 0; i < sizeof(packet) / sizeof(word); ++i) {
w = (const NetworkOrdered<u16>*)&packet;
for (size_t i = 0; i < sizeof(packet) / sizeof(u16); ++i) {
checksum += w[i];
if (checksum > 0xffff)
checksum = (checksum >> 16) + (checksum & 0xffff);
}
ASSERT(packet.data_offset() * 4 == sizeof(TCPPacket));
w = (const NetworkOrdered<word>*)packet.payload();
for (size_t i = 0; i < payload_size / sizeof(word); ++i) {
w = (const NetworkOrdered<u16>*)packet.payload();
for (size_t i = 0; i < payload_size / sizeof(u16); ++i) {
checksum += w[i];
if (checksum > 0xffff)
checksum = (checksum >> 16) + (checksum & 0xffff);
}
if (payload_size & 1) {
word expanded_byte = ((const byte*)packet.payload())[payload_size - 1] << 8;
u16 expanded_byte = ((const u8*)packet.payload())[payload_size - 1] << 8;
checksum += expanded_byte;
if (checksum > 0xffff)
checksum = (checksum >> 16) + (checksum & 0xffff);
@ -171,13 +171,13 @@ KResult TCPSocket::protocol_connect(FileDescription& description, ShouldBlock sh
int TCPSocket::protocol_allocate_local_port()
{
static const word first_ephemeral_port = 32768;
static const word last_ephemeral_port = 60999;
static const word ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
word first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
static const u16 first_ephemeral_port = 32768;
static const u16 last_ephemeral_port = 60999;
static const u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
u16 first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
LOCKER(sockets_by_port().lock());
for (word port = first_scan_port;;) {
for (u16 port = first_scan_port;;) {
auto it = sockets_by_port().resource().find(port);
if (it == sockets_by_port().resource().end()) {
set_local_port(port);

View file

@ -17,21 +17,21 @@ public:
State state() const { return m_state; }
void set_state(State state) { m_state = state; }
void set_ack_number(dword n) { m_ack_number = n; }
void set_sequence_number(dword n) { m_sequence_number = n; }
dword ack_number() const { return m_ack_number; }
dword sequence_number() const { return m_sequence_number; }
void set_ack_number(u32 n) { m_ack_number = n; }
void set_sequence_number(u32 n) { m_sequence_number = n; }
u32 ack_number() const { return m_ack_number; }
u32 sequence_number() const { return m_sequence_number; }
void send_tcp_packet(word flags, const void* = nullptr, int = 0);
void send_tcp_packet(u16 flags, const void* = nullptr, int = 0);
static Lockable<HashMap<word, TCPSocket*>>& sockets_by_port();
static TCPSocketHandle from_port(word);
static Lockable<HashMap<u16, TCPSocket*>>& sockets_by_port();
static TCPSocketHandle from_port(u16);
private:
explicit TCPSocket(int protocol);
virtual const char* class_name() const override { return "TCPSocket"; }
static NetworkOrdered<word> compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket&, word payload_size);
static NetworkOrdered<u16> compute_tcp_checksum(const IPv4Address& source, const IPv4Address& destination, const TCPPacket&, u16 payload_size);
virtual int protocol_receive(const ByteBuffer&, void* buffer, size_t buffer_size, int flags) override;
virtual int protocol_send(const void*, int) override;
@ -40,8 +40,8 @@ private:
virtual bool protocol_is_disconnected() const override;
virtual KResult protocol_bind() override;
dword m_sequence_number { 0 };
dword m_ack_number { 0 };
u32 m_sequence_number { 0 };
u32 m_ack_number { 0 };
State m_state { State::Disconnected };
};

View file

@ -8,26 +8,26 @@ public:
UDPPacket() {}
~UDPPacket() {}
word source_port() const { return m_source_port; }
void set_source_port(word port) { m_source_port = port; }
u16 source_port() const { return m_source_port; }
void set_source_port(u16 port) { m_source_port = port; }
word destination_port() const { return m_destination_port; }
void set_destination_port(word port) { m_destination_port = port; }
u16 destination_port() const { return m_destination_port; }
void set_destination_port(u16 port) { m_destination_port = port; }
word length() const { return m_length; }
void set_length(word length) { m_length = length; }
u16 length() const { return m_length; }
void set_length(u16 length) { m_length = length; }
word checksum() const { return m_checksum; }
void set_checksum(word checksum) { m_checksum = checksum; }
u16 checksum() const { return m_checksum; }
void set_checksum(u16 checksum) { m_checksum = checksum; }
const void* payload() const { return this + 1; }
void* payload() { return this + 1; }
private:
NetworkOrdered<word> m_source_port;
NetworkOrdered<word> m_destination_port;
NetworkOrdered<word> m_length;
NetworkOrdered<word> m_checksum;
NetworkOrdered<u16> m_source_port;
NetworkOrdered<u16> m_destination_port;
NetworkOrdered<u16> m_length;
NetworkOrdered<u16> m_checksum;
};
static_assert(sizeof(UDPPacket) == 8);

View file

@ -5,15 +5,15 @@
#include <Kernel/Net/UDPSocket.h>
#include <Kernel/Process.h>
Lockable<HashMap<word, UDPSocket*>>& UDPSocket::sockets_by_port()
Lockable<HashMap<u16, UDPSocket*>>& UDPSocket::sockets_by_port()
{
static Lockable<HashMap<word, UDPSocket*>>* s_map;
static Lockable<HashMap<u16, UDPSocket*>>* s_map;
if (!s_map)
s_map = new Lockable<HashMap<word, UDPSocket*>>;
s_map = new Lockable<HashMap<u16, UDPSocket*>>;
return *s_map;
}
UDPSocketHandle UDPSocket::from_port(word port)
UDPSocketHandle UDPSocket::from_port(u16 port)
{
RefPtr<UDPSocket> socket;
{
@ -77,13 +77,13 @@ int UDPSocket::protocol_send(const void* data, int data_length)
int UDPSocket::protocol_allocate_local_port()
{
static const word first_ephemeral_port = 32768;
static const word last_ephemeral_port = 60999;
static const word ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
word first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
static const u16 first_ephemeral_port = 32768;
static const u16 last_ephemeral_port = 60999;
static const u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
u16 first_scan_port = first_ephemeral_port + RandomDevice::random_value() % ephemeral_port_range_size;
LOCKER(sockets_by_port().lock());
for (word port = first_scan_port;;) {
for (u16 port = first_scan_port;;) {
auto it = sockets_by_port().resource().find(port);
if (it == sockets_by_port().resource().end()) {
set_local_port(port);

View file

@ -9,12 +9,12 @@ public:
static NonnullRefPtr<UDPSocket> create(int protocol);
virtual ~UDPSocket() override;
static UDPSocketHandle from_port(word);
static UDPSocketHandle from_port(u16);
private:
explicit UDPSocket(int protocol);
virtual const char* class_name() const override { return "UDPSocket"; }
static Lockable<HashMap<word, UDPSocket*>>& sockets_by_port();
static Lockable<HashMap<u16, UDPSocket*>>& sockets_by_port();
virtual int protocol_receive(const ByteBuffer&, void* buffer, size_t buffer_size, int flags) override;
virtual int protocol_send(const void*, int) override;