122 lines
3.4 KiB
D
122 lines
3.4 KiB
D
/**
|
|
* Defines various address types for use with HTTP communication.
|
|
*/
|
|
module handy_http_primitives.address;
|
|
|
|
/**
|
|
* Represents a 4-byte IPv4 network address and the port number on this machine
|
|
* that the connection was assigned to.
|
|
*/
|
|
struct IPv4InternetAddress {
|
|
const ubyte[4] bytes;
|
|
const ushort port;
|
|
|
|
string toString() const {
|
|
char[21] buffer;
|
|
size_t idx;
|
|
for (size_t i = 0; i < 4; i++) {
|
|
writeUIntToBuffer(bytes[i], buffer, idx);
|
|
if (i < 3) buffer[idx++] = '.';
|
|
}
|
|
buffer[idx++] = ':';
|
|
writeUIntToBuffer(port, buffer, idx);
|
|
return buffer[0 .. idx].idup;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Represents a 16-byte IPv6 network address and the port number on this
|
|
* machine that the connection was assigned to.
|
|
*/
|
|
struct IPv6InternetAddress {
|
|
const ubyte[16] bytes;
|
|
const ushort port;
|
|
|
|
string toString() const {
|
|
return "Not implemented!";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Represents a unix socket address, which is just a path to a file at which
|
|
* IO operations take place.
|
|
*/
|
|
struct UnixSocketAddress {
|
|
const string path;
|
|
|
|
string toString() const {
|
|
return path;
|
|
}
|
|
}
|
|
|
|
/// Defines the different possible address types, used by `ClientAddress`.
|
|
enum ClientAddressType {
|
|
IPv4,
|
|
IPv6,
|
|
UNIX
|
|
}
|
|
|
|
/**
|
|
* A compound type representing the address of any entity sending an HTTP
|
|
* request. Use `type` to determine which information is available.
|
|
*/
|
|
struct ClientAddress {
|
|
const ClientAddressType type;
|
|
const IPv4InternetAddress ipv4InternetAddress;
|
|
const IPv6InternetAddress ipv6InternetAddress;
|
|
const UnixSocketAddress unixSocketAddress;
|
|
|
|
string toString() const {
|
|
if (type == ClientAddressType.IPv4) {
|
|
return ipv4InternetAddress.toString();
|
|
} else if (type == ClientAddressType.IPv6) {
|
|
return ipv6InternetAddress.toString();
|
|
} else {
|
|
return unixSocketAddress.toString();
|
|
}
|
|
}
|
|
|
|
static ClientAddress ofIPv4(IPv4InternetAddress addr) {
|
|
return ClientAddress(ClientAddressType.IPv4, addr, IPv6InternetAddress.init, UnixSocketAddress.init);
|
|
}
|
|
|
|
static ClientAddress ofIPv6(IPv6InternetAddress addr) {
|
|
return ClientAddress(ClientAddressType.IPv6, IPv4InternetAddress.init, addr, UnixSocketAddress.init);
|
|
}
|
|
|
|
static ClientAddress ofUnixSocket(UnixSocketAddress addr) {
|
|
return ClientAddress(ClientAddressType.UNIX, IPv4InternetAddress.init, IPv6InternetAddress.init, addr);
|
|
}
|
|
}
|
|
|
|
unittest {
|
|
ClientAddress addr = ClientAddress.ofIPv4(IPv4InternetAddress([127, 0, 0, 1], 8000));
|
|
assert(addr.toString == "127.0.0.1:8000");
|
|
}
|
|
|
|
/**
|
|
* Helper function to append an unsigned integer value to a char buffer. It is
|
|
* assumed that there's enough space to write value.
|
|
* Params:
|
|
* value = The value to append.
|
|
* buffer = The buffer to append to.
|
|
* idx = A reference to a variable tracking the next writable index in the buffer.
|
|
*/
|
|
private void writeUIntToBuffer(uint value, char[] buffer, ref size_t idx) {
|
|
const size_t startIdx = idx;
|
|
while (true) {
|
|
ubyte remainder = value % 10;
|
|
value /= 10;
|
|
buffer[idx++] = cast(char) ('0' + remainder);
|
|
if (value == 0) break;
|
|
}
|
|
// Swap the characters to proper order.
|
|
for (size_t i = 0; i < (idx - startIdx) / 2; i++) {
|
|
size_t p1 = i + startIdx;
|
|
size_t p2 = idx - i - 1;
|
|
char tmp = buffer[p1];
|
|
buffer[p1] = buffer[p2];
|
|
buffer[p2] = tmp;
|
|
}
|
|
}
|