mirror of
https://github.com/ziglang/zig.git
synced 2024-11-28 23:30:13 +00:00
e8c4e79499
It is now composed of these main sections:
* Declarations that are shared among all operating systems.
* Declarations that have the same name, but different type signatures
depending on the operating system. Often multiple operating systems
share the same type signatures however.
* Declarations that are specific to a single operating system.
- These are imported one per line so you can see where they come from,
protected by a comptime block to prevent accessing the wrong one.
Closes #19352 by changing the convention to making types `void` and
functions `{}`, so that it becomes possible to update `@hasDecl` sites
to use `@TypeOf(f) != void` or `T != void`. Happily, this ended up
removing some duplicate logic and update some bitrotted feature
detection checks.
A handful of types have been modified to gain namespacing and type
safety. This is a breaking change.
Oh, and the last usage of `usingnamespace` site is eliminated.
1938 lines
66 KiB
Zig
1938 lines
66 KiB
Zig
//! Cross-platform networking abstractions.
|
|
|
|
const std = @import("std.zig");
|
|
const builtin = @import("builtin");
|
|
const assert = std.debug.assert;
|
|
const net = @This();
|
|
const mem = std.mem;
|
|
const posix = std.posix;
|
|
const fs = std.fs;
|
|
const io = std.io;
|
|
const native_endian = builtin.target.cpu.arch.endian();
|
|
const native_os = builtin.os.tag;
|
|
const windows = std.os.windows;
|
|
|
|
// Windows 10 added support for unix sockets in build 17063, redstone 4 is the
|
|
// first release to support them.
|
|
pub const has_unix_sockets = switch (native_os) {
|
|
.windows => builtin.os.version_range.windows.isAtLeast(.win10_rs4) orelse false,
|
|
else => true,
|
|
};
|
|
|
|
pub const IPParseError = error{
|
|
Overflow,
|
|
InvalidEnd,
|
|
InvalidCharacter,
|
|
Incomplete,
|
|
};
|
|
|
|
pub const IPv4ParseError = IPParseError || error{NonCanonical};
|
|
|
|
pub const IPv6ParseError = IPParseError || error{InvalidIpv4Mapping};
|
|
pub const IPv6InterfaceError = posix.SocketError || posix.IoCtl_SIOCGIFINDEX_Error || error{NameTooLong};
|
|
pub const IPv6ResolveError = IPv6ParseError || IPv6InterfaceError;
|
|
|
|
pub const Address = extern union {
|
|
any: posix.sockaddr,
|
|
in: Ip4Address,
|
|
in6: Ip6Address,
|
|
un: if (has_unix_sockets) posix.sockaddr.un else void,
|
|
|
|
/// Parse the given IP address string into an Address value.
|
|
/// It is recommended to use `resolveIp` instead, to handle
|
|
/// IPv6 link-local unix addresses.
|
|
pub fn parseIp(name: []const u8, port: u16) !Address {
|
|
if (parseIp4(name, port)) |ip4| return ip4 else |err| switch (err) {
|
|
error.Overflow,
|
|
error.InvalidEnd,
|
|
error.InvalidCharacter,
|
|
error.Incomplete,
|
|
error.NonCanonical,
|
|
=> {},
|
|
}
|
|
|
|
if (parseIp6(name, port)) |ip6| return ip6 else |err| switch (err) {
|
|
error.Overflow,
|
|
error.InvalidEnd,
|
|
error.InvalidCharacter,
|
|
error.Incomplete,
|
|
error.InvalidIpv4Mapping,
|
|
=> {},
|
|
}
|
|
|
|
return error.InvalidIPAddressFormat;
|
|
}
|
|
|
|
pub fn resolveIp(name: []const u8, port: u16) !Address {
|
|
if (parseIp4(name, port)) |ip4| return ip4 else |err| switch (err) {
|
|
error.Overflow,
|
|
error.InvalidEnd,
|
|
error.InvalidCharacter,
|
|
error.Incomplete,
|
|
error.NonCanonical,
|
|
=> {},
|
|
}
|
|
|
|
if (resolveIp6(name, port)) |ip6| return ip6 else |err| switch (err) {
|
|
error.Overflow,
|
|
error.InvalidEnd,
|
|
error.InvalidCharacter,
|
|
error.Incomplete,
|
|
error.InvalidIpv4Mapping,
|
|
=> {},
|
|
else => return err,
|
|
}
|
|
|
|
return error.InvalidIPAddressFormat;
|
|
}
|
|
|
|
pub fn parseExpectingFamily(name: []const u8, family: posix.sa_family_t, port: u16) !Address {
|
|
switch (family) {
|
|
posix.AF.INET => return parseIp4(name, port),
|
|
posix.AF.INET6 => return parseIp6(name, port),
|
|
posix.AF.UNSPEC => return parseIp(name, port),
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
pub fn parseIp6(buf: []const u8, port: u16) IPv6ParseError!Address {
|
|
return .{ .in6 = try Ip6Address.parse(buf, port) };
|
|
}
|
|
|
|
pub fn resolveIp6(buf: []const u8, port: u16) IPv6ResolveError!Address {
|
|
return .{ .in6 = try Ip6Address.resolve(buf, port) };
|
|
}
|
|
|
|
pub fn parseIp4(buf: []const u8, port: u16) IPv4ParseError!Address {
|
|
return .{ .in = try Ip4Address.parse(buf, port) };
|
|
}
|
|
|
|
pub fn initIp4(addr: [4]u8, port: u16) Address {
|
|
return .{ .in = Ip4Address.init(addr, port) };
|
|
}
|
|
|
|
pub fn initIp6(addr: [16]u8, port: u16, flowinfo: u32, scope_id: u32) Address {
|
|
return .{ .in6 = Ip6Address.init(addr, port, flowinfo, scope_id) };
|
|
}
|
|
|
|
pub fn initUnix(path: []const u8) !Address {
|
|
var sock_addr = posix.sockaddr.un{
|
|
.family = posix.AF.UNIX,
|
|
.path = undefined,
|
|
};
|
|
|
|
// Add 1 to ensure a terminating 0 is present in the path array for maximum portability.
|
|
if (path.len + 1 > sock_addr.path.len) return error.NameTooLong;
|
|
|
|
@memset(&sock_addr.path, 0);
|
|
@memcpy(sock_addr.path[0..path.len], path);
|
|
|
|
return .{ .un = sock_addr };
|
|
}
|
|
|
|
/// Returns the port in native endian.
|
|
/// Asserts that the address is ip4 or ip6.
|
|
pub fn getPort(self: Address) u16 {
|
|
return switch (self.any.family) {
|
|
posix.AF.INET => self.in.getPort(),
|
|
posix.AF.INET6 => self.in6.getPort(),
|
|
else => unreachable,
|
|
};
|
|
}
|
|
|
|
/// `port` is native-endian.
|
|
/// Asserts that the address is ip4 or ip6.
|
|
pub fn setPort(self: *Address, port: u16) void {
|
|
switch (self.any.family) {
|
|
posix.AF.INET => self.in.setPort(port),
|
|
posix.AF.INET6 => self.in6.setPort(port),
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
/// Asserts that `addr` is an IP address.
|
|
/// This function will read past the end of the pointer, with a size depending
|
|
/// on the address family.
|
|
pub fn initPosix(addr: *align(4) const posix.sockaddr) Address {
|
|
switch (addr.family) {
|
|
posix.AF.INET => return Address{ .in = Ip4Address{ .sa = @as(*const posix.sockaddr.in, @ptrCast(addr)).* } },
|
|
posix.AF.INET6 => return Address{ .in6 = Ip6Address{ .sa = @as(*const posix.sockaddr.in6, @ptrCast(addr)).* } },
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
pub fn format(
|
|
self: Address,
|
|
comptime fmt: []const u8,
|
|
options: std.fmt.FormatOptions,
|
|
out_stream: anytype,
|
|
) !void {
|
|
if (fmt.len != 0) std.fmt.invalidFmtError(fmt, self);
|
|
switch (self.any.family) {
|
|
posix.AF.INET => try self.in.format(fmt, options, out_stream),
|
|
posix.AF.INET6 => try self.in6.format(fmt, options, out_stream),
|
|
posix.AF.UNIX => {
|
|
if (!has_unix_sockets) {
|
|
unreachable;
|
|
}
|
|
|
|
try std.fmt.format(out_stream, "{s}", .{std.mem.sliceTo(&self.un.path, 0)});
|
|
},
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
pub fn eql(a: Address, b: Address) bool {
|
|
const a_bytes = @as([*]const u8, @ptrCast(&a.any))[0..a.getOsSockLen()];
|
|
const b_bytes = @as([*]const u8, @ptrCast(&b.any))[0..b.getOsSockLen()];
|
|
return mem.eql(u8, a_bytes, b_bytes);
|
|
}
|
|
|
|
pub fn getOsSockLen(self: Address) posix.socklen_t {
|
|
switch (self.any.family) {
|
|
posix.AF.INET => return self.in.getOsSockLen(),
|
|
posix.AF.INET6 => return self.in6.getOsSockLen(),
|
|
posix.AF.UNIX => {
|
|
if (!has_unix_sockets) {
|
|
unreachable;
|
|
}
|
|
|
|
// Using the full length of the structure here is more portable than returning
|
|
// the number of bytes actually used by the currently stored path.
|
|
// This also is correct regardless if we are passing a socket address to the kernel
|
|
// (e.g. in bind, connect, sendto) since we ensure the path is 0 terminated in
|
|
// initUnix() or if we are receiving a socket address from the kernel and must
|
|
// provide the full buffer size (e.g. getsockname, getpeername, recvfrom, accept).
|
|
//
|
|
// To access the path, std.mem.sliceTo(&address.un.path, 0) should be used.
|
|
return @as(posix.socklen_t, @intCast(@sizeOf(posix.sockaddr.un)));
|
|
},
|
|
|
|
else => unreachable,
|
|
}
|
|
}
|
|
|
|
pub const ListenError = posix.SocketError || posix.BindError || posix.ListenError ||
|
|
posix.SetSockOptError || posix.GetSockNameError;
|
|
|
|
pub const ListenOptions = struct {
|
|
/// How many connections the kernel will accept on the application's behalf.
|
|
/// If more than this many connections pool in the kernel, clients will start
|
|
/// seeing "Connection refused".
|
|
kernel_backlog: u31 = 128,
|
|
/// Sets SO_REUSEADDR and SO_REUSEPORT on POSIX.
|
|
/// Sets SO_REUSEADDR on Windows, which is roughly equivalent.
|
|
reuse_address: bool = false,
|
|
/// Deprecated. Does the same thing as reuse_address.
|
|
reuse_port: bool = false,
|
|
force_nonblocking: bool = false,
|
|
};
|
|
|
|
/// The returned `Server` has an open `stream`.
|
|
pub fn listen(address: Address, options: ListenOptions) ListenError!Server {
|
|
const nonblock: u32 = if (options.force_nonblocking) posix.SOCK.NONBLOCK else 0;
|
|
const sock_flags = posix.SOCK.STREAM | posix.SOCK.CLOEXEC | nonblock;
|
|
const proto: u32 = if (address.any.family == posix.AF.UNIX) 0 else posix.IPPROTO.TCP;
|
|
|
|
const sockfd = try posix.socket(address.any.family, sock_flags, proto);
|
|
var s: Server = .{
|
|
.listen_address = undefined,
|
|
.stream = .{ .handle = sockfd },
|
|
};
|
|
errdefer s.stream.close();
|
|
|
|
if (options.reuse_address or options.reuse_port) {
|
|
try posix.setsockopt(
|
|
sockfd,
|
|
posix.SOL.SOCKET,
|
|
posix.SO.REUSEADDR,
|
|
&mem.toBytes(@as(c_int, 1)),
|
|
);
|
|
if (@hasDecl(posix.SO, "REUSEPORT")) {
|
|
try posix.setsockopt(
|
|
sockfd,
|
|
posix.SOL.SOCKET,
|
|
posix.SO.REUSEPORT,
|
|
&mem.toBytes(@as(c_int, 1)),
|
|
);
|
|
}
|
|
}
|
|
|
|
var socklen = address.getOsSockLen();
|
|
try posix.bind(sockfd, &address.any, socklen);
|
|
try posix.listen(sockfd, options.kernel_backlog);
|
|
try posix.getsockname(sockfd, &s.listen_address.any, &socklen);
|
|
return s;
|
|
}
|
|
};
|
|
|
|
pub const Ip4Address = extern struct {
|
|
sa: posix.sockaddr.in,
|
|
|
|
pub fn parse(buf: []const u8, port: u16) IPv4ParseError!Ip4Address {
|
|
var result: Ip4Address = .{
|
|
.sa = .{
|
|
.port = mem.nativeToBig(u16, port),
|
|
.addr = undefined,
|
|
},
|
|
};
|
|
const out_ptr = mem.asBytes(&result.sa.addr);
|
|
|
|
var x: u8 = 0;
|
|
var index: u8 = 0;
|
|
var saw_any_digits = false;
|
|
var has_zero_prefix = false;
|
|
for (buf) |c| {
|
|
if (c == '.') {
|
|
if (!saw_any_digits) {
|
|
return error.InvalidCharacter;
|
|
}
|
|
if (index == 3) {
|
|
return error.InvalidEnd;
|
|
}
|
|
out_ptr[index] = x;
|
|
index += 1;
|
|
x = 0;
|
|
saw_any_digits = false;
|
|
has_zero_prefix = false;
|
|
} else if (c >= '0' and c <= '9') {
|
|
if (c == '0' and !saw_any_digits) {
|
|
has_zero_prefix = true;
|
|
} else if (has_zero_prefix) {
|
|
return error.NonCanonical;
|
|
}
|
|
saw_any_digits = true;
|
|
x = try std.math.mul(u8, x, 10);
|
|
x = try std.math.add(u8, x, c - '0');
|
|
} else {
|
|
return error.InvalidCharacter;
|
|
}
|
|
}
|
|
if (index == 3 and saw_any_digits) {
|
|
out_ptr[index] = x;
|
|
return result;
|
|
}
|
|
|
|
return error.Incomplete;
|
|
}
|
|
|
|
pub fn resolveIp(name: []const u8, port: u16) !Ip4Address {
|
|
if (parse(name, port)) |ip4| return ip4 else |err| switch (err) {
|
|
error.Overflow,
|
|
error.InvalidEnd,
|
|
error.InvalidCharacter,
|
|
error.Incomplete,
|
|
error.NonCanonical,
|
|
=> {},
|
|
}
|
|
return error.InvalidIPAddressFormat;
|
|
}
|
|
|
|
pub fn init(addr: [4]u8, port: u16) Ip4Address {
|
|
return Ip4Address{
|
|
.sa = posix.sockaddr.in{
|
|
.port = mem.nativeToBig(u16, port),
|
|
.addr = @as(*align(1) const u32, @ptrCast(&addr)).*,
|
|
},
|
|
};
|
|
}
|
|
|
|
/// Returns the port in native endian.
|
|
/// Asserts that the address is ip4 or ip6.
|
|
pub fn getPort(self: Ip4Address) u16 {
|
|
return mem.bigToNative(u16, self.sa.port);
|
|
}
|
|
|
|
/// `port` is native-endian.
|
|
/// Asserts that the address is ip4 or ip6.
|
|
pub fn setPort(self: *Ip4Address, port: u16) void {
|
|
self.sa.port = mem.nativeToBig(u16, port);
|
|
}
|
|
|
|
pub fn format(
|
|
self: Ip4Address,
|
|
comptime fmt: []const u8,
|
|
options: std.fmt.FormatOptions,
|
|
out_stream: anytype,
|
|
) !void {
|
|
if (fmt.len != 0) std.fmt.invalidFmtError(fmt, self);
|
|
_ = options;
|
|
const bytes = @as(*const [4]u8, @ptrCast(&self.sa.addr));
|
|
try std.fmt.format(out_stream, "{}.{}.{}.{}:{}", .{
|
|
bytes[0],
|
|
bytes[1],
|
|
bytes[2],
|
|
bytes[3],
|
|
self.getPort(),
|
|
});
|
|
}
|
|
|
|
pub fn getOsSockLen(self: Ip4Address) posix.socklen_t {
|
|
_ = self;
|
|
return @sizeOf(posix.sockaddr.in);
|
|
}
|
|
};
|
|
|
|
pub const Ip6Address = extern struct {
|
|
sa: posix.sockaddr.in6,
|
|
|
|
/// Parse a given IPv6 address string into an Address.
|
|
/// Assumes the Scope ID of the address is fully numeric.
|
|
/// For non-numeric addresses, see `resolveIp6`.
|
|
pub fn parse(buf: []const u8, port: u16) IPv6ParseError!Ip6Address {
|
|
var result = Ip6Address{
|
|
.sa = posix.sockaddr.in6{
|
|
.scope_id = 0,
|
|
.port = mem.nativeToBig(u16, port),
|
|
.flowinfo = 0,
|
|
.addr = undefined,
|
|
},
|
|
};
|
|
var ip_slice: *[16]u8 = result.sa.addr[0..];
|
|
|
|
var tail: [16]u8 = undefined;
|
|
|
|
var x: u16 = 0;
|
|
var saw_any_digits = false;
|
|
var index: u8 = 0;
|
|
var scope_id = false;
|
|
var abbrv = false;
|
|
for (buf, 0..) |c, i| {
|
|
if (scope_id) {
|
|
if (c >= '0' and c <= '9') {
|
|
const digit = c - '0';
|
|
{
|
|
const ov = @mulWithOverflow(result.sa.scope_id, 10);
|
|
if (ov[1] != 0) return error.Overflow;
|
|
result.sa.scope_id = ov[0];
|
|
}
|
|
{
|
|
const ov = @addWithOverflow(result.sa.scope_id, digit);
|
|
if (ov[1] != 0) return error.Overflow;
|
|
result.sa.scope_id = ov[0];
|
|
}
|
|
} else {
|
|
return error.InvalidCharacter;
|
|
}
|
|
} else if (c == ':') {
|
|
if (!saw_any_digits) {
|
|
if (abbrv) return error.InvalidCharacter; // ':::'
|
|
if (i != 0) abbrv = true;
|
|
@memset(ip_slice[index..], 0);
|
|
ip_slice = tail[0..];
|
|
index = 0;
|
|
continue;
|
|
}
|
|
if (index == 14) {
|
|
return error.InvalidEnd;
|
|
}
|
|
ip_slice[index] = @as(u8, @truncate(x >> 8));
|
|
index += 1;
|
|
ip_slice[index] = @as(u8, @truncate(x));
|
|
index += 1;
|
|
|
|
x = 0;
|
|
saw_any_digits = false;
|
|
} else if (c == '%') {
|
|
if (!saw_any_digits) {
|
|
return error.InvalidCharacter;
|
|
}
|
|
scope_id = true;
|
|
saw_any_digits = false;
|
|
} else if (c == '.') {
|
|
if (!abbrv or ip_slice[0] != 0xff or ip_slice[1] != 0xff) {
|
|
// must start with '::ffff:'
|
|
return error.InvalidIpv4Mapping;
|
|
}
|
|
const start_index = mem.lastIndexOfScalar(u8, buf[0..i], ':').? + 1;
|
|
const addr = (Ip4Address.parse(buf[start_index..], 0) catch {
|
|
return error.InvalidIpv4Mapping;
|
|
}).sa.addr;
|
|
ip_slice = result.sa.addr[0..];
|
|
ip_slice[10] = 0xff;
|
|
ip_slice[11] = 0xff;
|
|
|
|
const ptr = mem.sliceAsBytes(@as(*const [1]u32, &addr)[0..]);
|
|
|
|
ip_slice[12] = ptr[0];
|
|
ip_slice[13] = ptr[1];
|
|
ip_slice[14] = ptr[2];
|
|
ip_slice[15] = ptr[3];
|
|
return result;
|
|
} else {
|
|
const digit = try std.fmt.charToDigit(c, 16);
|
|
{
|
|
const ov = @mulWithOverflow(x, 16);
|
|
if (ov[1] != 0) return error.Overflow;
|
|
x = ov[0];
|
|
}
|
|
{
|
|
const ov = @addWithOverflow(x, digit);
|
|
if (ov[1] != 0) return error.Overflow;
|
|
x = ov[0];
|
|
}
|
|
saw_any_digits = true;
|
|
}
|
|
}
|
|
|
|
if (!saw_any_digits and !abbrv) {
|
|
return error.Incomplete;
|
|
}
|
|
if (!abbrv and index < 14) {
|
|
return error.Incomplete;
|
|
}
|
|
|
|
if (index == 14) {
|
|
ip_slice[14] = @as(u8, @truncate(x >> 8));
|
|
ip_slice[15] = @as(u8, @truncate(x));
|
|
return result;
|
|
} else {
|
|
ip_slice[index] = @as(u8, @truncate(x >> 8));
|
|
index += 1;
|
|
ip_slice[index] = @as(u8, @truncate(x));
|
|
index += 1;
|
|
@memcpy(result.sa.addr[16 - index ..][0..index], ip_slice[0..index]);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
pub fn resolve(buf: []const u8, port: u16) IPv6ResolveError!Ip6Address {
|
|
// TODO: Unify the implementations of resolveIp6 and parseIp6.
|
|
var result = Ip6Address{
|
|
.sa = posix.sockaddr.in6{
|
|
.scope_id = 0,
|
|
.port = mem.nativeToBig(u16, port),
|
|
.flowinfo = 0,
|
|
.addr = undefined,
|
|
},
|
|
};
|
|
var ip_slice: *[16]u8 = result.sa.addr[0..];
|
|
|
|
var tail: [16]u8 = undefined;
|
|
|
|
var x: u16 = 0;
|
|
var saw_any_digits = false;
|
|
var index: u8 = 0;
|
|
var abbrv = false;
|
|
|
|
var scope_id = false;
|
|
var scope_id_value: [posix.IFNAMESIZE - 1]u8 = undefined;
|
|
var scope_id_index: usize = 0;
|
|
|
|
for (buf, 0..) |c, i| {
|
|
if (scope_id) {
|
|
// Handling of percent-encoding should be for an URI library.
|
|
if ((c >= '0' and c <= '9') or
|
|
(c >= 'A' and c <= 'Z') or
|
|
(c >= 'a' and c <= 'z') or
|
|
(c == '-') or (c == '.') or (c == '_') or (c == '~'))
|
|
{
|
|
if (scope_id_index >= scope_id_value.len) {
|
|
return error.Overflow;
|
|
}
|
|
|
|
scope_id_value[scope_id_index] = c;
|
|
scope_id_index += 1;
|
|
} else {
|
|
return error.InvalidCharacter;
|
|
}
|
|
} else if (c == ':') {
|
|
if (!saw_any_digits) {
|
|
if (abbrv) return error.InvalidCharacter; // ':::'
|
|
if (i != 0) abbrv = true;
|
|
@memset(ip_slice[index..], 0);
|
|
ip_slice = tail[0..];
|
|
index = 0;
|
|
continue;
|
|
}
|
|
if (index == 14) {
|
|
return error.InvalidEnd;
|
|
}
|
|
ip_slice[index] = @as(u8, @truncate(x >> 8));
|
|
index += 1;
|
|
ip_slice[index] = @as(u8, @truncate(x));
|
|
index += 1;
|
|
|
|
x = 0;
|
|
saw_any_digits = false;
|
|
} else if (c == '%') {
|
|
if (!saw_any_digits) {
|
|
return error.InvalidCharacter;
|
|
}
|
|
scope_id = true;
|
|
saw_any_digits = false;
|
|
} else if (c == '.') {
|
|
if (!abbrv or ip_slice[0] != 0xff or ip_slice[1] != 0xff) {
|
|
// must start with '::ffff:'
|
|
return error.InvalidIpv4Mapping;
|
|
}
|
|
const start_index = mem.lastIndexOfScalar(u8, buf[0..i], ':').? + 1;
|
|
const addr = (Ip4Address.parse(buf[start_index..], 0) catch {
|
|
return error.InvalidIpv4Mapping;
|
|
}).sa.addr;
|
|
ip_slice = result.sa.addr[0..];
|
|
ip_slice[10] = 0xff;
|
|
ip_slice[11] = 0xff;
|
|
|
|
const ptr = mem.sliceAsBytes(@as(*const [1]u32, &addr)[0..]);
|
|
|
|
ip_slice[12] = ptr[0];
|
|
ip_slice[13] = ptr[1];
|
|
ip_slice[14] = ptr[2];
|
|
ip_slice[15] = ptr[3];
|
|
return result;
|
|
} else {
|
|
const digit = try std.fmt.charToDigit(c, 16);
|
|
{
|
|
const ov = @mulWithOverflow(x, 16);
|
|
if (ov[1] != 0) return error.Overflow;
|
|
x = ov[0];
|
|
}
|
|
{
|
|
const ov = @addWithOverflow(x, digit);
|
|
if (ov[1] != 0) return error.Overflow;
|
|
x = ov[0];
|
|
}
|
|
saw_any_digits = true;
|
|
}
|
|
}
|
|
|
|
if (!saw_any_digits and !abbrv) {
|
|
return error.Incomplete;
|
|
}
|
|
|
|
if (scope_id and scope_id_index == 0) {
|
|
return error.Incomplete;
|
|
}
|
|
|
|
var resolved_scope_id: u32 = 0;
|
|
if (scope_id_index > 0) {
|
|
const scope_id_str = scope_id_value[0..scope_id_index];
|
|
resolved_scope_id = std.fmt.parseInt(u32, scope_id_str, 10) catch |err| blk: {
|
|
if (err != error.InvalidCharacter) return err;
|
|
break :blk try if_nametoindex(scope_id_str);
|
|
};
|
|
}
|
|
|
|
result.sa.scope_id = resolved_scope_id;
|
|
|
|
if (index == 14) {
|
|
ip_slice[14] = @as(u8, @truncate(x >> 8));
|
|
ip_slice[15] = @as(u8, @truncate(x));
|
|
return result;
|
|
} else {
|
|
ip_slice[index] = @as(u8, @truncate(x >> 8));
|
|
index += 1;
|
|
ip_slice[index] = @as(u8, @truncate(x));
|
|
index += 1;
|
|
@memcpy(result.sa.addr[16 - index ..][0..index], ip_slice[0..index]);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
pub fn init(addr: [16]u8, port: u16, flowinfo: u32, scope_id: u32) Ip6Address {
|
|
return Ip6Address{
|
|
.sa = posix.sockaddr.in6{
|
|
.addr = addr,
|
|
.port = mem.nativeToBig(u16, port),
|
|
.flowinfo = flowinfo,
|
|
.scope_id = scope_id,
|
|
},
|
|
};
|
|
}
|
|
|
|
/// Returns the port in native endian.
|
|
/// Asserts that the address is ip4 or ip6.
|
|
pub fn getPort(self: Ip6Address) u16 {
|
|
return mem.bigToNative(u16, self.sa.port);
|
|
}
|
|
|
|
/// `port` is native-endian.
|
|
/// Asserts that the address is ip4 or ip6.
|
|
pub fn setPort(self: *Ip6Address, port: u16) void {
|
|
self.sa.port = mem.nativeToBig(u16, port);
|
|
}
|
|
|
|
pub fn format(
|
|
self: Ip6Address,
|
|
comptime fmt: []const u8,
|
|
options: std.fmt.FormatOptions,
|
|
out_stream: anytype,
|
|
) !void {
|
|
if (fmt.len != 0) std.fmt.invalidFmtError(fmt, self);
|
|
_ = options;
|
|
const port = mem.bigToNative(u16, self.sa.port);
|
|
if (mem.eql(u8, self.sa.addr[0..12], &[_]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff })) {
|
|
try std.fmt.format(out_stream, "[::ffff:{}.{}.{}.{}]:{}", .{
|
|
self.sa.addr[12],
|
|
self.sa.addr[13],
|
|
self.sa.addr[14],
|
|
self.sa.addr[15],
|
|
port,
|
|
});
|
|
return;
|
|
}
|
|
const big_endian_parts = @as(*align(1) const [8]u16, @ptrCast(&self.sa.addr));
|
|
const native_endian_parts = switch (native_endian) {
|
|
.big => big_endian_parts.*,
|
|
.little => blk: {
|
|
var buf: [8]u16 = undefined;
|
|
for (big_endian_parts, 0..) |part, i| {
|
|
buf[i] = mem.bigToNative(u16, part);
|
|
}
|
|
break :blk buf;
|
|
},
|
|
};
|
|
try out_stream.writeAll("[");
|
|
var i: usize = 0;
|
|
var abbrv = false;
|
|
while (i < native_endian_parts.len) : (i += 1) {
|
|
if (native_endian_parts[i] == 0) {
|
|
if (!abbrv) {
|
|
try out_stream.writeAll(if (i == 0) "::" else ":");
|
|
abbrv = true;
|
|
}
|
|
continue;
|
|
}
|
|
try std.fmt.format(out_stream, "{x}", .{native_endian_parts[i]});
|
|
if (i != native_endian_parts.len - 1) {
|
|
try out_stream.writeAll(":");
|
|
}
|
|
}
|
|
try std.fmt.format(out_stream, "]:{}", .{port});
|
|
}
|
|
|
|
pub fn getOsSockLen(self: Ip6Address) posix.socklen_t {
|
|
_ = self;
|
|
return @sizeOf(posix.sockaddr.in6);
|
|
}
|
|
};
|
|
|
|
pub fn connectUnixSocket(path: []const u8) !Stream {
|
|
const opt_non_block = 0;
|
|
const sockfd = try posix.socket(
|
|
posix.AF.UNIX,
|
|
posix.SOCK.STREAM | posix.SOCK.CLOEXEC | opt_non_block,
|
|
0,
|
|
);
|
|
errdefer Stream.close(.{ .handle = sockfd });
|
|
|
|
var addr = try std.net.Address.initUnix(path);
|
|
try posix.connect(sockfd, &addr.any, addr.getOsSockLen());
|
|
|
|
return .{ .handle = sockfd };
|
|
}
|
|
|
|
fn if_nametoindex(name: []const u8) IPv6InterfaceError!u32 {
|
|
if (native_os == .linux) {
|
|
var ifr: posix.ifreq = undefined;
|
|
const sockfd = try posix.socket(posix.AF.UNIX, posix.SOCK.DGRAM | posix.SOCK.CLOEXEC, 0);
|
|
defer Stream.close(.{ .handle = sockfd });
|
|
|
|
@memcpy(ifr.ifrn.name[0..name.len], name);
|
|
ifr.ifrn.name[name.len] = 0;
|
|
|
|
// TODO investigate if this needs to be integrated with evented I/O.
|
|
try posix.ioctl_SIOCGIFINDEX(sockfd, &ifr);
|
|
|
|
return @bitCast(ifr.ifru.ivalue);
|
|
}
|
|
|
|
if (native_os.isDarwin()) {
|
|
if (name.len >= posix.IFNAMESIZE)
|
|
return error.NameTooLong;
|
|
|
|
var if_name: [posix.IFNAMESIZE:0]u8 = undefined;
|
|
@memcpy(if_name[0..name.len], name);
|
|
if_name[name.len] = 0;
|
|
const if_slice = if_name[0..name.len :0];
|
|
const index = std.c.if_nametoindex(if_slice);
|
|
if (index == 0)
|
|
return error.InterfaceNotFound;
|
|
return @as(u32, @bitCast(index));
|
|
}
|
|
|
|
@compileError("std.net.if_nametoindex unimplemented for this OS");
|
|
}
|
|
|
|
pub const AddressList = struct {
|
|
arena: std.heap.ArenaAllocator,
|
|
addrs: []Address,
|
|
canon_name: ?[]u8,
|
|
|
|
pub fn deinit(self: *AddressList) void {
|
|
// Here we copy the arena allocator into stack memory, because
|
|
// otherwise it would destroy itself while it was still working.
|
|
var arena = self.arena;
|
|
arena.deinit();
|
|
// self is destroyed
|
|
}
|
|
};
|
|
|
|
pub const TcpConnectToHostError = GetAddressListError || TcpConnectToAddressError;
|
|
|
|
/// All memory allocated with `allocator` will be freed before this function returns.
|
|
pub fn tcpConnectToHost(allocator: mem.Allocator, name: []const u8, port: u16) TcpConnectToHostError!Stream {
|
|
const list = try getAddressList(allocator, name, port);
|
|
defer list.deinit();
|
|
|
|
if (list.addrs.len == 0) return error.UnknownHostName;
|
|
|
|
for (list.addrs) |addr| {
|
|
return tcpConnectToAddress(addr) catch |err| switch (err) {
|
|
error.ConnectionRefused => {
|
|
continue;
|
|
},
|
|
else => return err,
|
|
};
|
|
}
|
|
return posix.ConnectError.ConnectionRefused;
|
|
}
|
|
|
|
pub const TcpConnectToAddressError = posix.SocketError || posix.ConnectError;
|
|
|
|
pub fn tcpConnectToAddress(address: Address) TcpConnectToAddressError!Stream {
|
|
const nonblock = 0;
|
|
const sock_flags = posix.SOCK.STREAM | nonblock |
|
|
(if (native_os == .windows) 0 else posix.SOCK.CLOEXEC);
|
|
const sockfd = try posix.socket(address.any.family, sock_flags, posix.IPPROTO.TCP);
|
|
errdefer Stream.close(.{ .handle = sockfd });
|
|
|
|
try posix.connect(sockfd, &address.any, address.getOsSockLen());
|
|
|
|
return Stream{ .handle = sockfd };
|
|
}
|
|
|
|
const GetAddressListError = std.mem.Allocator.Error || std.fs.File.OpenError || std.fs.File.ReadError || posix.SocketError || posix.BindError || posix.SetSockOptError || error{
|
|
// TODO: break this up into error sets from the various underlying functions
|
|
|
|
TemporaryNameServerFailure,
|
|
NameServerFailure,
|
|
AddressFamilyNotSupported,
|
|
UnknownHostName,
|
|
ServiceUnavailable,
|
|
Unexpected,
|
|
|
|
HostLacksNetworkAddresses,
|
|
|
|
InvalidCharacter,
|
|
InvalidEnd,
|
|
NonCanonical,
|
|
Overflow,
|
|
Incomplete,
|
|
InvalidIpv4Mapping,
|
|
InvalidIPAddressFormat,
|
|
|
|
InterfaceNotFound,
|
|
FileSystem,
|
|
};
|
|
|
|
/// Call `AddressList.deinit` on the result.
|
|
pub fn getAddressList(allocator: mem.Allocator, name: []const u8, port: u16) GetAddressListError!*AddressList {
|
|
const result = blk: {
|
|
var arena = std.heap.ArenaAllocator.init(allocator);
|
|
errdefer arena.deinit();
|
|
|
|
const result = try arena.allocator().create(AddressList);
|
|
result.* = AddressList{
|
|
.arena = arena,
|
|
.addrs = undefined,
|
|
.canon_name = null,
|
|
};
|
|
break :blk result;
|
|
};
|
|
const arena = result.arena.allocator();
|
|
errdefer result.deinit();
|
|
|
|
if (native_os == .windows) {
|
|
const name_c = try allocator.dupeZ(u8, name);
|
|
defer allocator.free(name_c);
|
|
|
|
const port_c = try std.fmt.allocPrintZ(allocator, "{}", .{port});
|
|
defer allocator.free(port_c);
|
|
|
|
const ws2_32 = windows.ws2_32;
|
|
const hints: posix.addrinfo = .{
|
|
.flags = .{ .NUMERICSERV = true },
|
|
.family = posix.AF.UNSPEC,
|
|
.socktype = posix.SOCK.STREAM,
|
|
.protocol = posix.IPPROTO.TCP,
|
|
.canonname = null,
|
|
.addr = null,
|
|
.addrlen = 0,
|
|
.next = null,
|
|
};
|
|
var res: ?*posix.addrinfo = null;
|
|
var first = true;
|
|
while (true) {
|
|
const rc = ws2_32.getaddrinfo(name_c.ptr, port_c.ptr, &hints, &res);
|
|
switch (@as(windows.ws2_32.WinsockError, @enumFromInt(@as(u16, @intCast(rc))))) {
|
|
@as(windows.ws2_32.WinsockError, @enumFromInt(0)) => break,
|
|
.WSATRY_AGAIN => return error.TemporaryNameServerFailure,
|
|
.WSANO_RECOVERY => return error.NameServerFailure,
|
|
.WSAEAFNOSUPPORT => return error.AddressFamilyNotSupported,
|
|
.WSA_NOT_ENOUGH_MEMORY => return error.OutOfMemory,
|
|
.WSAHOST_NOT_FOUND => return error.UnknownHostName,
|
|
.WSATYPE_NOT_FOUND => return error.ServiceUnavailable,
|
|
.WSAEINVAL => unreachable,
|
|
.WSAESOCKTNOSUPPORT => unreachable,
|
|
.WSANOTINITIALISED => {
|
|
if (!first) return error.Unexpected;
|
|
first = false;
|
|
try windows.callWSAStartup();
|
|
continue;
|
|
},
|
|
else => |err| return windows.unexpectedWSAError(err),
|
|
}
|
|
}
|
|
defer ws2_32.freeaddrinfo(res);
|
|
|
|
const addr_count = blk: {
|
|
var count: usize = 0;
|
|
var it = res;
|
|
while (it) |info| : (it = info.next) {
|
|
if (info.addr != null) {
|
|
count += 1;
|
|
}
|
|
}
|
|
break :blk count;
|
|
};
|
|
result.addrs = try arena.alloc(Address, addr_count);
|
|
|
|
var it = res;
|
|
var i: usize = 0;
|
|
while (it) |info| : (it = info.next) {
|
|
const addr = info.addr orelse continue;
|
|
result.addrs[i] = Address.initPosix(@alignCast(addr));
|
|
|
|
if (info.canonname) |n| {
|
|
if (result.canon_name == null) {
|
|
result.canon_name = try arena.dupe(u8, mem.sliceTo(n, 0));
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
if (builtin.link_libc) {
|
|
const name_c = try allocator.dupeZ(u8, name);
|
|
defer allocator.free(name_c);
|
|
|
|
const port_c = try std.fmt.allocPrintZ(allocator, "{}", .{port});
|
|
defer allocator.free(port_c);
|
|
|
|
const sys = if (native_os == .windows) windows.ws2_32 else posix.system;
|
|
const hints: posix.addrinfo = .{
|
|
.flags = .{ .NUMERICSERV = true },
|
|
.family = posix.AF.UNSPEC,
|
|
.socktype = posix.SOCK.STREAM,
|
|
.protocol = posix.IPPROTO.TCP,
|
|
.canonname = null,
|
|
.addr = null,
|
|
.addrlen = 0,
|
|
.next = null,
|
|
};
|
|
var res: ?*posix.addrinfo = null;
|
|
switch (sys.getaddrinfo(name_c.ptr, port_c.ptr, &hints, &res)) {
|
|
@as(sys.EAI, @enumFromInt(0)) => {},
|
|
.ADDRFAMILY => return error.HostLacksNetworkAddresses,
|
|
.AGAIN => return error.TemporaryNameServerFailure,
|
|
.BADFLAGS => unreachable, // Invalid hints
|
|
.FAIL => return error.NameServerFailure,
|
|
.FAMILY => return error.AddressFamilyNotSupported,
|
|
.MEMORY => return error.OutOfMemory,
|
|
.NODATA => return error.HostLacksNetworkAddresses,
|
|
.NONAME => return error.UnknownHostName,
|
|
.SERVICE => return error.ServiceUnavailable,
|
|
.SOCKTYPE => unreachable, // Invalid socket type requested in hints
|
|
.SYSTEM => switch (posix.errno(-1)) {
|
|
else => |e| return posix.unexpectedErrno(e),
|
|
},
|
|
else => unreachable,
|
|
}
|
|
defer if (res) |some| sys.freeaddrinfo(some);
|
|
|
|
const addr_count = blk: {
|
|
var count: usize = 0;
|
|
var it = res;
|
|
while (it) |info| : (it = info.next) {
|
|
if (info.addr != null) {
|
|
count += 1;
|
|
}
|
|
}
|
|
break :blk count;
|
|
};
|
|
result.addrs = try arena.alloc(Address, addr_count);
|
|
|
|
var it = res;
|
|
var i: usize = 0;
|
|
while (it) |info| : (it = info.next) {
|
|
const addr = info.addr orelse continue;
|
|
result.addrs[i] = Address.initPosix(@alignCast(addr));
|
|
|
|
if (info.canonname) |n| {
|
|
if (result.canon_name == null) {
|
|
result.canon_name = try arena.dupe(u8, mem.sliceTo(n, 0));
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
if (native_os == .linux) {
|
|
const family = posix.AF.UNSPEC;
|
|
var lookup_addrs = std.ArrayList(LookupAddr).init(allocator);
|
|
defer lookup_addrs.deinit();
|
|
|
|
var canon = std.ArrayList(u8).init(arena);
|
|
defer canon.deinit();
|
|
|
|
try linuxLookupName(&lookup_addrs, &canon, name, family, .{ .NUMERICSERV = true }, port);
|
|
|
|
result.addrs = try arena.alloc(Address, lookup_addrs.items.len);
|
|
if (canon.items.len != 0) {
|
|
result.canon_name = try canon.toOwnedSlice();
|
|
}
|
|
|
|
for (lookup_addrs.items, 0..) |lookup_addr, i| {
|
|
result.addrs[i] = lookup_addr.addr;
|
|
assert(result.addrs[i].getPort() == port);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
@compileError("std.net.getAddressList unimplemented for this OS");
|
|
}
|
|
|
|
const LookupAddr = struct {
|
|
addr: Address,
|
|
sortkey: i32 = 0,
|
|
};
|
|
|
|
const DAS_USABLE = 0x40000000;
|
|
const DAS_MATCHINGSCOPE = 0x20000000;
|
|
const DAS_MATCHINGLABEL = 0x10000000;
|
|
const DAS_PREC_SHIFT = 20;
|
|
const DAS_SCOPE_SHIFT = 16;
|
|
const DAS_PREFIX_SHIFT = 8;
|
|
const DAS_ORDER_SHIFT = 0;
|
|
|
|
fn linuxLookupName(
|
|
addrs: *std.ArrayList(LookupAddr),
|
|
canon: *std.ArrayList(u8),
|
|
opt_name: ?[]const u8,
|
|
family: posix.sa_family_t,
|
|
flags: posix.AI,
|
|
port: u16,
|
|
) !void {
|
|
if (opt_name) |name| {
|
|
// reject empty name and check len so it fits into temp bufs
|
|
canon.items.len = 0;
|
|
try canon.appendSlice(name);
|
|
if (Address.parseExpectingFamily(name, family, port)) |addr| {
|
|
try addrs.append(LookupAddr{ .addr = addr });
|
|
} else |name_err| if (flags.NUMERICHOST) {
|
|
return name_err;
|
|
} else {
|
|
try linuxLookupNameFromHosts(addrs, canon, name, family, port);
|
|
if (addrs.items.len == 0) {
|
|
// RFC 6761 Section 6.3.3
|
|
// Name resolution APIs and libraries SHOULD recognize localhost
|
|
// names as special and SHOULD always return the IP loopback address
|
|
// for address queries and negative responses for all other query
|
|
// types.
|
|
|
|
// Check for equal to "localhost(.)" or ends in ".localhost(.)"
|
|
const localhost = if (name[name.len - 1] == '.') "localhost." else "localhost";
|
|
if (mem.endsWith(u8, name, localhost) and (name.len == localhost.len or name[name.len - localhost.len] == '.')) {
|
|
try addrs.append(LookupAddr{ .addr = .{ .in = Ip4Address.parse("127.0.0.1", port) catch unreachable } });
|
|
try addrs.append(LookupAddr{ .addr = .{ .in6 = Ip6Address.parse("::1", port) catch unreachable } });
|
|
return;
|
|
}
|
|
|
|
try linuxLookupNameFromDnsSearch(addrs, canon, name, family, port);
|
|
}
|
|
}
|
|
} else {
|
|
try canon.resize(0);
|
|
try linuxLookupNameFromNull(addrs, family, flags, port);
|
|
}
|
|
if (addrs.items.len == 0) return error.UnknownHostName;
|
|
|
|
// No further processing is needed if there are fewer than 2
|
|
// results or if there are only IPv4 results.
|
|
if (addrs.items.len == 1 or family == posix.AF.INET) return;
|
|
const all_ip4 = for (addrs.items) |addr| {
|
|
if (addr.addr.any.family != posix.AF.INET) break false;
|
|
} else true;
|
|
if (all_ip4) return;
|
|
|
|
// The following implements a subset of RFC 3484/6724 destination
|
|
// address selection by generating a single 31-bit sort key for
|
|
// each address. Rules 3, 4, and 7 are omitted for having
|
|
// excessive runtime and code size cost and dubious benefit.
|
|
// So far the label/precedence table cannot be customized.
|
|
// This implementation is ported from musl libc.
|
|
// A more idiomatic "ziggy" implementation would be welcome.
|
|
for (addrs.items, 0..) |*addr, i| {
|
|
var key: i32 = 0;
|
|
var sa6: posix.sockaddr.in6 = undefined;
|
|
@memset(@as([*]u8, @ptrCast(&sa6))[0..@sizeOf(posix.sockaddr.in6)], 0);
|
|
var da6 = posix.sockaddr.in6{
|
|
.family = posix.AF.INET6,
|
|
.scope_id = addr.addr.in6.sa.scope_id,
|
|
.port = 65535,
|
|
.flowinfo = 0,
|
|
.addr = [1]u8{0} ** 16,
|
|
};
|
|
var sa4: posix.sockaddr.in = undefined;
|
|
@memset(@as([*]u8, @ptrCast(&sa4))[0..@sizeOf(posix.sockaddr.in)], 0);
|
|
var da4 = posix.sockaddr.in{
|
|
.family = posix.AF.INET,
|
|
.port = 65535,
|
|
.addr = 0,
|
|
.zero = [1]u8{0} ** 8,
|
|
};
|
|
var sa: *align(4) posix.sockaddr = undefined;
|
|
var da: *align(4) posix.sockaddr = undefined;
|
|
var salen: posix.socklen_t = undefined;
|
|
var dalen: posix.socklen_t = undefined;
|
|
if (addr.addr.any.family == posix.AF.INET6) {
|
|
da6.addr = addr.addr.in6.sa.addr;
|
|
da = @ptrCast(&da6);
|
|
dalen = @sizeOf(posix.sockaddr.in6);
|
|
sa = @ptrCast(&sa6);
|
|
salen = @sizeOf(posix.sockaddr.in6);
|
|
} else {
|
|
sa6.addr[0..12].* = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff".*;
|
|
da6.addr[0..12].* = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff".*;
|
|
mem.writeInt(u32, da6.addr[12..], addr.addr.in.sa.addr, native_endian);
|
|
da4.addr = addr.addr.in.sa.addr;
|
|
da = @ptrCast(&da4);
|
|
dalen = @sizeOf(posix.sockaddr.in);
|
|
sa = @ptrCast(&sa4);
|
|
salen = @sizeOf(posix.sockaddr.in);
|
|
}
|
|
const dpolicy = policyOf(da6.addr);
|
|
const dscope: i32 = scopeOf(da6.addr);
|
|
const dlabel = dpolicy.label;
|
|
const dprec: i32 = dpolicy.prec;
|
|
const MAXADDRS = 3;
|
|
var prefixlen: i32 = 0;
|
|
const sock_flags = posix.SOCK.DGRAM | posix.SOCK.CLOEXEC;
|
|
if (posix.socket(addr.addr.any.family, sock_flags, posix.IPPROTO.UDP)) |fd| syscalls: {
|
|
defer Stream.close(.{ .handle = fd });
|
|
posix.connect(fd, da, dalen) catch break :syscalls;
|
|
key |= DAS_USABLE;
|
|
posix.getsockname(fd, sa, &salen) catch break :syscalls;
|
|
if (addr.addr.any.family == posix.AF.INET) {
|
|
mem.writeInt(u32, sa6.addr[12..16], sa4.addr, native_endian);
|
|
}
|
|
if (dscope == @as(i32, scopeOf(sa6.addr))) key |= DAS_MATCHINGSCOPE;
|
|
if (dlabel == labelOf(sa6.addr)) key |= DAS_MATCHINGLABEL;
|
|
prefixlen = prefixMatch(sa6.addr, da6.addr);
|
|
} else |_| {}
|
|
key |= dprec << DAS_PREC_SHIFT;
|
|
key |= (15 - dscope) << DAS_SCOPE_SHIFT;
|
|
key |= prefixlen << DAS_PREFIX_SHIFT;
|
|
key |= (MAXADDRS - @as(i32, @intCast(i))) << DAS_ORDER_SHIFT;
|
|
addr.sortkey = key;
|
|
}
|
|
mem.sort(LookupAddr, addrs.items, {}, addrCmpLessThan);
|
|
}
|
|
|
|
const Policy = struct {
|
|
addr: [16]u8,
|
|
len: u8,
|
|
mask: u8,
|
|
prec: u8,
|
|
label: u8,
|
|
};
|
|
|
|
const defined_policies = [_]Policy{
|
|
Policy{
|
|
.addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01".*,
|
|
.len = 15,
|
|
.mask = 0xff,
|
|
.prec = 50,
|
|
.label = 0,
|
|
},
|
|
Policy{
|
|
.addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00".*,
|
|
.len = 11,
|
|
.mask = 0xff,
|
|
.prec = 35,
|
|
.label = 4,
|
|
},
|
|
Policy{
|
|
.addr = "\x20\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*,
|
|
.len = 1,
|
|
.mask = 0xff,
|
|
.prec = 30,
|
|
.label = 2,
|
|
},
|
|
Policy{
|
|
.addr = "\x20\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*,
|
|
.len = 3,
|
|
.mask = 0xff,
|
|
.prec = 5,
|
|
.label = 5,
|
|
},
|
|
Policy{
|
|
.addr = "\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*,
|
|
.len = 0,
|
|
.mask = 0xfe,
|
|
.prec = 3,
|
|
.label = 13,
|
|
},
|
|
// These are deprecated and/or returned to the address
|
|
// pool, so despite the RFC, treating them as special
|
|
// is probably wrong.
|
|
// { "", 11, 0xff, 1, 3 },
|
|
// { "\xfe\xc0", 1, 0xc0, 1, 11 },
|
|
// { "\x3f\xfe", 1, 0xff, 1, 12 },
|
|
// Last rule must match all addresses to stop loop.
|
|
Policy{
|
|
.addr = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00".*,
|
|
.len = 0,
|
|
.mask = 0,
|
|
.prec = 40,
|
|
.label = 1,
|
|
},
|
|
};
|
|
|
|
fn policyOf(a: [16]u8) *const Policy {
|
|
for (&defined_policies) |*policy| {
|
|
if (!mem.eql(u8, a[0..policy.len], policy.addr[0..policy.len])) continue;
|
|
if ((a[policy.len] & policy.mask) != policy.addr[policy.len]) continue;
|
|
return policy;
|
|
}
|
|
unreachable;
|
|
}
|
|
|
|
fn scopeOf(a: [16]u8) u8 {
|
|
if (IN6_IS_ADDR_MULTICAST(a)) return a[1] & 15;
|
|
if (IN6_IS_ADDR_LINKLOCAL(a)) return 2;
|
|
if (IN6_IS_ADDR_LOOPBACK(a)) return 2;
|
|
if (IN6_IS_ADDR_SITELOCAL(a)) return 5;
|
|
return 14;
|
|
}
|
|
|
|
fn prefixMatch(s: [16]u8, d: [16]u8) u8 {
|
|
// TODO: This FIXME inherited from porting from musl libc.
|
|
// I don't want this to go into zig std lib 1.0.0.
|
|
|
|
// FIXME: The common prefix length should be limited to no greater
|
|
// than the nominal length of the prefix portion of the source
|
|
// address. However the definition of the source prefix length is
|
|
// not clear and thus this limiting is not yet implemented.
|
|
var i: u8 = 0;
|
|
while (i < 128 and ((s[i / 8] ^ d[i / 8]) & (@as(u8, 128) >> @as(u3, @intCast(i % 8)))) == 0) : (i += 1) {}
|
|
return i;
|
|
}
|
|
|
|
fn labelOf(a: [16]u8) u8 {
|
|
return policyOf(a).label;
|
|
}
|
|
|
|
fn IN6_IS_ADDR_MULTICAST(a: [16]u8) bool {
|
|
return a[0] == 0xff;
|
|
}
|
|
|
|
fn IN6_IS_ADDR_LINKLOCAL(a: [16]u8) bool {
|
|
return a[0] == 0xfe and (a[1] & 0xc0) == 0x80;
|
|
}
|
|
|
|
fn IN6_IS_ADDR_LOOPBACK(a: [16]u8) bool {
|
|
return a[0] == 0 and a[1] == 0 and
|
|
a[2] == 0 and
|
|
a[12] == 0 and a[13] == 0 and
|
|
a[14] == 0 and a[15] == 1;
|
|
}
|
|
|
|
fn IN6_IS_ADDR_SITELOCAL(a: [16]u8) bool {
|
|
return a[0] == 0xfe and (a[1] & 0xc0) == 0xc0;
|
|
}
|
|
|
|
// Parameters `b` and `a` swapped to make this descending.
|
|
fn addrCmpLessThan(context: void, b: LookupAddr, a: LookupAddr) bool {
|
|
_ = context;
|
|
return a.sortkey < b.sortkey;
|
|
}
|
|
|
|
fn linuxLookupNameFromNull(
|
|
addrs: *std.ArrayList(LookupAddr),
|
|
family: posix.sa_family_t,
|
|
flags: posix.AI,
|
|
port: u16,
|
|
) !void {
|
|
if (flags.PASSIVE) {
|
|
if (family != posix.AF.INET6) {
|
|
(try addrs.addOne()).* = LookupAddr{
|
|
.addr = Address.initIp4([1]u8{0} ** 4, port),
|
|
};
|
|
}
|
|
if (family != posix.AF.INET) {
|
|
(try addrs.addOne()).* = LookupAddr{
|
|
.addr = Address.initIp6([1]u8{0} ** 16, port, 0, 0),
|
|
};
|
|
}
|
|
} else {
|
|
if (family != posix.AF.INET6) {
|
|
(try addrs.addOne()).* = LookupAddr{
|
|
.addr = Address.initIp4([4]u8{ 127, 0, 0, 1 }, port),
|
|
};
|
|
}
|
|
if (family != posix.AF.INET) {
|
|
(try addrs.addOne()).* = LookupAddr{
|
|
.addr = Address.initIp6(([1]u8{0} ** 15) ++ [1]u8{1}, port, 0, 0),
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
fn linuxLookupNameFromHosts(
|
|
addrs: *std.ArrayList(LookupAddr),
|
|
canon: *std.ArrayList(u8),
|
|
name: []const u8,
|
|
family: posix.sa_family_t,
|
|
port: u16,
|
|
) !void {
|
|
const file = fs.openFileAbsoluteZ("/etc/hosts", .{}) catch |err| switch (err) {
|
|
error.FileNotFound,
|
|
error.NotDir,
|
|
error.AccessDenied,
|
|
=> return,
|
|
else => |e| return e,
|
|
};
|
|
defer file.close();
|
|
|
|
var buffered_reader = std.io.bufferedReader(file.reader());
|
|
const reader = buffered_reader.reader();
|
|
var line_buf: [512]u8 = undefined;
|
|
while (reader.readUntilDelimiterOrEof(&line_buf, '\n') catch |err| switch (err) {
|
|
error.StreamTooLong => blk: {
|
|
// Skip to the delimiter in the reader, to fix parsing
|
|
try reader.skipUntilDelimiterOrEof('\n');
|
|
// Use the truncated line. A truncated comment or hostname will be handled correctly.
|
|
break :blk &line_buf;
|
|
},
|
|
else => |e| return e,
|
|
}) |line| {
|
|
var split_it = mem.splitScalar(u8, line, '#');
|
|
const no_comment_line = split_it.first();
|
|
|
|
var line_it = mem.tokenizeAny(u8, no_comment_line, " \t");
|
|
const ip_text = line_it.next() orelse continue;
|
|
var first_name_text: ?[]const u8 = null;
|
|
while (line_it.next()) |name_text| {
|
|
if (first_name_text == null) first_name_text = name_text;
|
|
if (mem.eql(u8, name_text, name)) {
|
|
break;
|
|
}
|
|
} else continue;
|
|
|
|
const addr = Address.parseExpectingFamily(ip_text, family, port) catch |err| switch (err) {
|
|
error.Overflow,
|
|
error.InvalidEnd,
|
|
error.InvalidCharacter,
|
|
error.Incomplete,
|
|
error.InvalidIPAddressFormat,
|
|
error.InvalidIpv4Mapping,
|
|
error.NonCanonical,
|
|
=> continue,
|
|
};
|
|
try addrs.append(LookupAddr{ .addr = addr });
|
|
|
|
// first name is canonical name
|
|
const name_text = first_name_text.?;
|
|
if (isValidHostName(name_text)) {
|
|
canon.items.len = 0;
|
|
try canon.appendSlice(name_text);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn isValidHostName(hostname: []const u8) bool {
|
|
if (hostname.len >= 254) return false;
|
|
if (!std.unicode.utf8ValidateSlice(hostname)) return false;
|
|
for (hostname) |byte| {
|
|
if (!std.ascii.isAscii(byte) or byte == '.' or byte == '-' or std.ascii.isAlphanumeric(byte)) {
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
fn linuxLookupNameFromDnsSearch(
|
|
addrs: *std.ArrayList(LookupAddr),
|
|
canon: *std.ArrayList(u8),
|
|
name: []const u8,
|
|
family: posix.sa_family_t,
|
|
port: u16,
|
|
) !void {
|
|
var rc: ResolvConf = undefined;
|
|
try getResolvConf(addrs.allocator, &rc);
|
|
defer rc.deinit();
|
|
|
|
// Count dots, suppress search when >=ndots or name ends in
|
|
// a dot, which is an explicit request for global scope.
|
|
var dots: usize = 0;
|
|
for (name) |byte| {
|
|
if (byte == '.') dots += 1;
|
|
}
|
|
|
|
const search = if (dots >= rc.ndots or mem.endsWith(u8, name, "."))
|
|
""
|
|
else
|
|
rc.search.items;
|
|
|
|
var canon_name = name;
|
|
|
|
// Strip final dot for canon, fail if multiple trailing dots.
|
|
if (mem.endsWith(u8, canon_name, ".")) canon_name.len -= 1;
|
|
if (mem.endsWith(u8, canon_name, ".")) return error.UnknownHostName;
|
|
|
|
// Name with search domain appended is setup in canon[]. This both
|
|
// provides the desired default canonical name (if the requested
|
|
// name is not a CNAME record) and serves as a buffer for passing
|
|
// the full requested name to name_from_dns.
|
|
try canon.resize(canon_name.len);
|
|
@memcpy(canon.items, canon_name);
|
|
try canon.append('.');
|
|
|
|
var tok_it = mem.tokenizeAny(u8, search, " \t");
|
|
while (tok_it.next()) |tok| {
|
|
canon.shrinkRetainingCapacity(canon_name.len + 1);
|
|
try canon.appendSlice(tok);
|
|
try linuxLookupNameFromDns(addrs, canon, canon.items, family, rc, port);
|
|
if (addrs.items.len != 0) return;
|
|
}
|
|
|
|
canon.shrinkRetainingCapacity(canon_name.len);
|
|
return linuxLookupNameFromDns(addrs, canon, name, family, rc, port);
|
|
}
|
|
|
|
const dpc_ctx = struct {
|
|
addrs: *std.ArrayList(LookupAddr),
|
|
canon: *std.ArrayList(u8),
|
|
port: u16,
|
|
};
|
|
|
|
fn linuxLookupNameFromDns(
|
|
addrs: *std.ArrayList(LookupAddr),
|
|
canon: *std.ArrayList(u8),
|
|
name: []const u8,
|
|
family: posix.sa_family_t,
|
|
rc: ResolvConf,
|
|
port: u16,
|
|
) !void {
|
|
const ctx = dpc_ctx{
|
|
.addrs = addrs,
|
|
.canon = canon,
|
|
.port = port,
|
|
};
|
|
const AfRr = struct {
|
|
af: posix.sa_family_t,
|
|
rr: u8,
|
|
};
|
|
const afrrs = [_]AfRr{
|
|
AfRr{ .af = posix.AF.INET6, .rr = posix.RR.A },
|
|
AfRr{ .af = posix.AF.INET, .rr = posix.RR.AAAA },
|
|
};
|
|
var qbuf: [2][280]u8 = undefined;
|
|
var abuf: [2][512]u8 = undefined;
|
|
var qp: [2][]const u8 = undefined;
|
|
const apbuf = [2][]u8{ &abuf[0], &abuf[1] };
|
|
var nq: usize = 0;
|
|
|
|
for (afrrs) |afrr| {
|
|
if (family != afrr.af) {
|
|
const len = posix.res_mkquery(0, name, 1, afrr.rr, &[_]u8{}, null, &qbuf[nq]);
|
|
qp[nq] = qbuf[nq][0..len];
|
|
nq += 1;
|
|
}
|
|
}
|
|
|
|
var ap = [2][]u8{ apbuf[0], apbuf[1] };
|
|
ap[0].len = 0;
|
|
ap[1].len = 0;
|
|
|
|
try resMSendRc(qp[0..nq], ap[0..nq], apbuf[0..nq], rc);
|
|
|
|
var i: usize = 0;
|
|
while (i < nq) : (i += 1) {
|
|
dnsParse(ap[i], ctx, dnsParseCallback) catch {};
|
|
}
|
|
|
|
if (addrs.items.len != 0) return;
|
|
if (ap[0].len < 4 or (ap[0][3] & 15) == 2) return error.TemporaryNameServerFailure;
|
|
if ((ap[0][3] & 15) == 0) return error.UnknownHostName;
|
|
if ((ap[0][3] & 15) == 3) return;
|
|
return error.NameServerFailure;
|
|
}
|
|
|
|
const ResolvConf = struct {
|
|
attempts: u32,
|
|
ndots: u32,
|
|
timeout: u32,
|
|
search: std.ArrayList(u8),
|
|
ns: std.ArrayList(LookupAddr),
|
|
|
|
fn deinit(rc: *ResolvConf) void {
|
|
rc.ns.deinit();
|
|
rc.search.deinit();
|
|
rc.* = undefined;
|
|
}
|
|
};
|
|
|
|
/// Ignores lines longer than 512 bytes.
|
|
/// TODO: https://github.com/ziglang/zig/issues/2765 and https://github.com/ziglang/zig/issues/2761
|
|
fn getResolvConf(allocator: mem.Allocator, rc: *ResolvConf) !void {
|
|
rc.* = ResolvConf{
|
|
.ns = std.ArrayList(LookupAddr).init(allocator),
|
|
.search = std.ArrayList(u8).init(allocator),
|
|
.ndots = 1,
|
|
.timeout = 5,
|
|
.attempts = 2,
|
|
};
|
|
errdefer rc.deinit();
|
|
|
|
const file = fs.openFileAbsoluteZ("/etc/resolv.conf", .{}) catch |err| switch (err) {
|
|
error.FileNotFound,
|
|
error.NotDir,
|
|
error.AccessDenied,
|
|
=> return linuxLookupNameFromNumericUnspec(&rc.ns, "127.0.0.1", 53),
|
|
else => |e| return e,
|
|
};
|
|
defer file.close();
|
|
|
|
var buf_reader = std.io.bufferedReader(file.reader());
|
|
const stream = buf_reader.reader();
|
|
var line_buf: [512]u8 = undefined;
|
|
while (stream.readUntilDelimiterOrEof(&line_buf, '\n') catch |err| switch (err) {
|
|
error.StreamTooLong => blk: {
|
|
// Skip to the delimiter in the stream, to fix parsing
|
|
try stream.skipUntilDelimiterOrEof('\n');
|
|
// Give an empty line to the while loop, which will be skipped.
|
|
break :blk line_buf[0..0];
|
|
},
|
|
else => |e| return e,
|
|
}) |line| {
|
|
const no_comment_line = no_comment_line: {
|
|
var split = mem.splitScalar(u8, line, '#');
|
|
break :no_comment_line split.first();
|
|
};
|
|
var line_it = mem.tokenizeAny(u8, no_comment_line, " \t");
|
|
|
|
const token = line_it.next() orelse continue;
|
|
if (mem.eql(u8, token, "options")) {
|
|
while (line_it.next()) |sub_tok| {
|
|
var colon_it = mem.splitScalar(u8, sub_tok, ':');
|
|
const name = colon_it.first();
|
|
const value_txt = colon_it.next() orelse continue;
|
|
const value = std.fmt.parseInt(u8, value_txt, 10) catch |err| switch (err) {
|
|
// TODO https://github.com/ziglang/zig/issues/11812
|
|
error.Overflow => @as(u8, 255),
|
|
error.InvalidCharacter => continue,
|
|
};
|
|
if (mem.eql(u8, name, "ndots")) {
|
|
rc.ndots = @min(value, 15);
|
|
} else if (mem.eql(u8, name, "attempts")) {
|
|
rc.attempts = @min(value, 10);
|
|
} else if (mem.eql(u8, name, "timeout")) {
|
|
rc.timeout = @min(value, 60);
|
|
}
|
|
}
|
|
} else if (mem.eql(u8, token, "nameserver")) {
|
|
const ip_txt = line_it.next() orelse continue;
|
|
try linuxLookupNameFromNumericUnspec(&rc.ns, ip_txt, 53);
|
|
} else if (mem.eql(u8, token, "domain") or mem.eql(u8, token, "search")) {
|
|
rc.search.items.len = 0;
|
|
try rc.search.appendSlice(line_it.rest());
|
|
}
|
|
}
|
|
|
|
if (rc.ns.items.len == 0) {
|
|
return linuxLookupNameFromNumericUnspec(&rc.ns, "127.0.0.1", 53);
|
|
}
|
|
}
|
|
|
|
fn linuxLookupNameFromNumericUnspec(
|
|
addrs: *std.ArrayList(LookupAddr),
|
|
name: []const u8,
|
|
port: u16,
|
|
) !void {
|
|
const addr = try Address.resolveIp(name, port);
|
|
(try addrs.addOne()).* = LookupAddr{ .addr = addr };
|
|
}
|
|
|
|
fn resMSendRc(
|
|
queries: []const []const u8,
|
|
answers: [][]u8,
|
|
answer_bufs: []const []u8,
|
|
rc: ResolvConf,
|
|
) !void {
|
|
const timeout = 1000 * rc.timeout;
|
|
const attempts = rc.attempts;
|
|
|
|
var sl: posix.socklen_t = @sizeOf(posix.sockaddr.in);
|
|
var family: posix.sa_family_t = posix.AF.INET;
|
|
|
|
var ns_list = std.ArrayList(Address).init(rc.ns.allocator);
|
|
defer ns_list.deinit();
|
|
|
|
try ns_list.resize(rc.ns.items.len);
|
|
const ns = ns_list.items;
|
|
|
|
for (rc.ns.items, 0..) |iplit, i| {
|
|
ns[i] = iplit.addr;
|
|
assert(ns[i].getPort() == 53);
|
|
if (iplit.addr.any.family != posix.AF.INET) {
|
|
family = posix.AF.INET6;
|
|
}
|
|
}
|
|
|
|
const flags = posix.SOCK.DGRAM | posix.SOCK.CLOEXEC | posix.SOCK.NONBLOCK;
|
|
const fd = posix.socket(family, flags, 0) catch |err| switch (err) {
|
|
error.AddressFamilyNotSupported => blk: {
|
|
// Handle case where system lacks IPv6 support
|
|
if (family == posix.AF.INET6) {
|
|
family = posix.AF.INET;
|
|
break :blk try posix.socket(posix.AF.INET, flags, 0);
|
|
}
|
|
return err;
|
|
},
|
|
else => |e| return e,
|
|
};
|
|
defer Stream.close(.{ .handle = fd });
|
|
|
|
// Past this point, there are no errors. Each individual query will
|
|
// yield either no reply (indicated by zero length) or an answer
|
|
// packet which is up to the caller to interpret.
|
|
|
|
// Convert any IPv4 addresses in a mixed environment to v4-mapped
|
|
if (family == posix.AF.INET6) {
|
|
try posix.setsockopt(
|
|
fd,
|
|
posix.SOL.IPV6,
|
|
std.os.linux.IPV6.V6ONLY,
|
|
&mem.toBytes(@as(c_int, 0)),
|
|
);
|
|
for (0..ns.len) |i| {
|
|
if (ns[i].any.family != posix.AF.INET) continue;
|
|
mem.writeInt(u32, ns[i].in6.sa.addr[12..], ns[i].in.sa.addr, native_endian);
|
|
ns[i].in6.sa.addr[0..12].* = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff".*;
|
|
ns[i].any.family = posix.AF.INET6;
|
|
ns[i].in6.sa.flowinfo = 0;
|
|
ns[i].in6.sa.scope_id = 0;
|
|
}
|
|
sl = @sizeOf(posix.sockaddr.in6);
|
|
}
|
|
|
|
// Get local address and open/bind a socket
|
|
var sa: Address = undefined;
|
|
@memset(@as([*]u8, @ptrCast(&sa))[0..@sizeOf(Address)], 0);
|
|
sa.any.family = family;
|
|
try posix.bind(fd, &sa.any, sl);
|
|
|
|
var pfd = [1]posix.pollfd{posix.pollfd{
|
|
.fd = fd,
|
|
.events = posix.POLL.IN,
|
|
.revents = undefined,
|
|
}};
|
|
const retry_interval = timeout / attempts;
|
|
var next: u32 = 0;
|
|
var t2: u64 = @bitCast(std.time.milliTimestamp());
|
|
const t0 = t2;
|
|
var t1 = t2 - retry_interval;
|
|
|
|
var servfail_retry: usize = undefined;
|
|
|
|
outer: while (t2 - t0 < timeout) : (t2 = @as(u64, @bitCast(std.time.milliTimestamp()))) {
|
|
if (t2 - t1 >= retry_interval) {
|
|
// Query all configured nameservers in parallel
|
|
var i: usize = 0;
|
|
while (i < queries.len) : (i += 1) {
|
|
if (answers[i].len == 0) {
|
|
var j: usize = 0;
|
|
while (j < ns.len) : (j += 1) {
|
|
_ = posix.sendto(fd, queries[i], posix.MSG.NOSIGNAL, &ns[j].any, sl) catch undefined;
|
|
}
|
|
}
|
|
}
|
|
t1 = t2;
|
|
servfail_retry = 2 * queries.len;
|
|
}
|
|
|
|
// Wait for a response, or until time to retry
|
|
const clamped_timeout = @min(@as(u31, std.math.maxInt(u31)), t1 + retry_interval - t2);
|
|
const nevents = posix.poll(&pfd, clamped_timeout) catch 0;
|
|
if (nevents == 0) continue;
|
|
|
|
while (true) {
|
|
var sl_copy = sl;
|
|
const rlen = posix.recvfrom(fd, answer_bufs[next], 0, &sa.any, &sl_copy) catch break;
|
|
|
|
// Ignore non-identifiable packets
|
|
if (rlen < 4) continue;
|
|
|
|
// Ignore replies from addresses we didn't send to
|
|
var j: usize = 0;
|
|
while (j < ns.len and !ns[j].eql(sa)) : (j += 1) {}
|
|
if (j == ns.len) continue;
|
|
|
|
// Find which query this answer goes with, if any
|
|
var i: usize = next;
|
|
while (i < queries.len and (answer_bufs[next][0] != queries[i][0] or
|
|
answer_bufs[next][1] != queries[i][1])) : (i += 1)
|
|
{}
|
|
|
|
if (i == queries.len) continue;
|
|
if (answers[i].len != 0) continue;
|
|
|
|
// Only accept positive or negative responses;
|
|
// retry immediately on server failure, and ignore
|
|
// all other codes such as refusal.
|
|
switch (answer_bufs[next][3] & 15) {
|
|
0, 3 => {},
|
|
2 => if (servfail_retry != 0) {
|
|
servfail_retry -= 1;
|
|
_ = posix.sendto(fd, queries[i], posix.MSG.NOSIGNAL, &ns[j].any, sl) catch undefined;
|
|
},
|
|
else => continue,
|
|
}
|
|
|
|
// Store answer in the right slot, or update next
|
|
// available temp slot if it's already in place.
|
|
answers[i].len = rlen;
|
|
if (i == next) {
|
|
while (next < queries.len and answers[next].len != 0) : (next += 1) {}
|
|
} else {
|
|
@memcpy(answer_bufs[i][0..rlen], answer_bufs[next][0..rlen]);
|
|
}
|
|
|
|
if (next == queries.len) break :outer;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn dnsParse(
|
|
r: []const u8,
|
|
ctx: anytype,
|
|
comptime callback: anytype,
|
|
) !void {
|
|
// This implementation is ported from musl libc.
|
|
// A more idiomatic "ziggy" implementation would be welcome.
|
|
if (r.len < 12) return error.InvalidDnsPacket;
|
|
if ((r[3] & 15) != 0) return;
|
|
var p = r.ptr + 12;
|
|
var qdcount = r[4] * @as(usize, 256) + r[5];
|
|
var ancount = r[6] * @as(usize, 256) + r[7];
|
|
if (qdcount + ancount > 64) return error.InvalidDnsPacket;
|
|
while (qdcount != 0) {
|
|
qdcount -= 1;
|
|
while (@intFromPtr(p) - @intFromPtr(r.ptr) < r.len and p[0] -% 1 < 127) p += 1;
|
|
if (p[0] > 193 or (p[0] == 193 and p[1] > 254) or @intFromPtr(p) > @intFromPtr(r.ptr) + r.len - 6)
|
|
return error.InvalidDnsPacket;
|
|
p += @as(usize, 5) + @intFromBool(p[0] != 0);
|
|
}
|
|
while (ancount != 0) {
|
|
ancount -= 1;
|
|
while (@intFromPtr(p) - @intFromPtr(r.ptr) < r.len and p[0] -% 1 < 127) p += 1;
|
|
if (p[0] > 193 or (p[0] == 193 and p[1] > 254) or @intFromPtr(p) > @intFromPtr(r.ptr) + r.len - 6)
|
|
return error.InvalidDnsPacket;
|
|
p += @as(usize, 1) + @intFromBool(p[0] != 0);
|
|
const len = p[8] * @as(usize, 256) + p[9];
|
|
if (@intFromPtr(p) + len > @intFromPtr(r.ptr) + r.len) return error.InvalidDnsPacket;
|
|
try callback(ctx, p[1], p[10..][0..len], r);
|
|
p += 10 + len;
|
|
}
|
|
}
|
|
|
|
fn dnsParseCallback(ctx: dpc_ctx, rr: u8, data: []const u8, packet: []const u8) !void {
|
|
switch (rr) {
|
|
posix.RR.A => {
|
|
if (data.len != 4) return error.InvalidDnsARecord;
|
|
const new_addr = try ctx.addrs.addOne();
|
|
new_addr.* = LookupAddr{
|
|
.addr = Address.initIp4(data[0..4].*, ctx.port),
|
|
};
|
|
},
|
|
posix.RR.AAAA => {
|
|
if (data.len != 16) return error.InvalidDnsAAAARecord;
|
|
const new_addr = try ctx.addrs.addOne();
|
|
new_addr.* = LookupAddr{
|
|
.addr = Address.initIp6(data[0..16].*, ctx.port, 0, 0),
|
|
};
|
|
},
|
|
posix.RR.CNAME => {
|
|
var tmp: [256]u8 = undefined;
|
|
// Returns len of compressed name. strlen to get canon name.
|
|
_ = try posix.dn_expand(packet, data, &tmp);
|
|
const canon_name = mem.sliceTo(&tmp, 0);
|
|
if (isValidHostName(canon_name)) {
|
|
ctx.canon.items.len = 0;
|
|
try ctx.canon.appendSlice(canon_name);
|
|
}
|
|
},
|
|
else => return,
|
|
}
|
|
}
|
|
|
|
pub const Stream = struct {
|
|
/// Underlying platform-defined type which may or may not be
|
|
/// interchangeable with a file system file descriptor.
|
|
handle: posix.socket_t,
|
|
|
|
pub fn close(s: Stream) void {
|
|
switch (native_os) {
|
|
.windows => windows.closesocket(s.handle) catch unreachable,
|
|
else => posix.close(s.handle),
|
|
}
|
|
}
|
|
|
|
pub const ReadError = posix.ReadError;
|
|
pub const WriteError = posix.WriteError;
|
|
|
|
pub const Reader = io.Reader(Stream, ReadError, read);
|
|
pub const Writer = io.Writer(Stream, WriteError, write);
|
|
|
|
pub fn reader(self: Stream) Reader {
|
|
return .{ .context = self };
|
|
}
|
|
|
|
pub fn writer(self: Stream) Writer {
|
|
return .{ .context = self };
|
|
}
|
|
|
|
pub fn read(self: Stream, buffer: []u8) ReadError!usize {
|
|
if (native_os == .windows) {
|
|
return windows.ReadFile(self.handle, buffer, null);
|
|
}
|
|
|
|
return posix.read(self.handle, buffer);
|
|
}
|
|
|
|
pub fn readv(s: Stream, iovecs: []const posix.iovec) ReadError!usize {
|
|
if (native_os == .windows) {
|
|
// TODO improve this to use ReadFileScatter
|
|
if (iovecs.len == 0) return @as(usize, 0);
|
|
const first = iovecs[0];
|
|
return windows.ReadFile(s.handle, first.base[0..first.len], null);
|
|
}
|
|
|
|
return posix.readv(s.handle, iovecs);
|
|
}
|
|
|
|
/// Returns the number of bytes read. If the number read is smaller than
|
|
/// `buffer.len`, it means the stream reached the end. Reaching the end of
|
|
/// a stream is not an error condition.
|
|
pub fn readAll(s: Stream, buffer: []u8) ReadError!usize {
|
|
return readAtLeast(s, buffer, buffer.len);
|
|
}
|
|
|
|
/// Returns the number of bytes read, calling the underlying read function
|
|
/// the minimal number of times until the buffer has at least `len` bytes
|
|
/// filled. If the number read is less than `len` it means the stream
|
|
/// reached the end. Reaching the end of the stream is not an error
|
|
/// condition.
|
|
pub fn readAtLeast(s: Stream, buffer: []u8, len: usize) ReadError!usize {
|
|
assert(len <= buffer.len);
|
|
var index: usize = 0;
|
|
while (index < len) {
|
|
const amt = try s.read(buffer[index..]);
|
|
if (amt == 0) break;
|
|
index += amt;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
/// TODO in evented I/O mode, this implementation incorrectly uses the event loop's
|
|
/// file system thread instead of non-blocking. It needs to be reworked to properly
|
|
/// use non-blocking I/O.
|
|
pub fn write(self: Stream, buffer: []const u8) WriteError!usize {
|
|
if (native_os == .windows) {
|
|
return windows.WriteFile(self.handle, buffer, null);
|
|
}
|
|
|
|
return posix.write(self.handle, buffer);
|
|
}
|
|
|
|
pub fn writeAll(self: Stream, bytes: []const u8) WriteError!void {
|
|
var index: usize = 0;
|
|
while (index < bytes.len) {
|
|
index += try self.write(bytes[index..]);
|
|
}
|
|
}
|
|
|
|
/// See https://github.com/ziglang/zig/issues/7699
|
|
/// See equivalent function: `std.fs.File.writev`.
|
|
pub fn writev(self: Stream, iovecs: []const posix.iovec_const) WriteError!usize {
|
|
return posix.writev(self.handle, iovecs);
|
|
}
|
|
|
|
/// The `iovecs` parameter is mutable because this function needs to mutate the fields in
|
|
/// order to handle partial writes from the underlying OS layer.
|
|
/// See https://github.com/ziglang/zig/issues/7699
|
|
/// See equivalent function: `std.fs.File.writevAll`.
|
|
pub fn writevAll(self: Stream, iovecs: []posix.iovec_const) WriteError!void {
|
|
if (iovecs.len == 0) return;
|
|
|
|
var i: usize = 0;
|
|
while (true) {
|
|
var amt = try self.writev(iovecs[i..]);
|
|
while (amt >= iovecs[i].len) {
|
|
amt -= iovecs[i].len;
|
|
i += 1;
|
|
if (i >= iovecs.len) return;
|
|
}
|
|
iovecs[i].base += amt;
|
|
iovecs[i].len -= amt;
|
|
}
|
|
}
|
|
};
|
|
|
|
pub const Server = struct {
|
|
listen_address: Address,
|
|
stream: std.net.Stream,
|
|
|
|
pub const Connection = struct {
|
|
stream: std.net.Stream,
|
|
address: Address,
|
|
};
|
|
|
|
pub fn deinit(s: *Server) void {
|
|
s.stream.close();
|
|
s.* = undefined;
|
|
}
|
|
|
|
pub const AcceptError = posix.AcceptError;
|
|
|
|
/// Blocks until a client connects to the server. The returned `Connection` has
|
|
/// an open stream.
|
|
pub fn accept(s: *Server) AcceptError!Connection {
|
|
var accepted_addr: Address = undefined;
|
|
var addr_len: posix.socklen_t = @sizeOf(Address);
|
|
const fd = try posix.accept(s.stream.handle, &accepted_addr.any, &addr_len, posix.SOCK.CLOEXEC);
|
|
return .{
|
|
.stream = .{ .handle = fd },
|
|
.address = accepted_addr,
|
|
};
|
|
}
|
|
};
|
|
|
|
test {
|
|
if (builtin.os.tag != .wasi) {
|
|
_ = Server;
|
|
_ = Stream;
|
|
_ = Address;
|
|
_ = @import("net/test.zig");
|
|
}
|
|
}
|