Commit 4b80e376e3
Changed files (4)
src-self-hosted
lib/std/os/bits/linux.zig
@@ -864,7 +864,7 @@ pub const sockaddr_in6 = extern struct {
family: sa_family_t,
port: in_port_t,
flowinfo: u32,
- addr: [16]u8,
+ addr: [8]u16,
scope_id: u32,
};
@@ -1384,3 +1384,85 @@ pub const Statx = extern struct {
__pad2: [14]u64,
};
+
+pub const addrinfo = extern struct {
+ flags: i32,
+ family: i32,
+ socktype: i32,
+ protocol: i32,
+ addrlen: socklen_t,
+ addr: ?*sockaddr,
+ canonname: ?[*]u8,
+ next: ?*addrinfo,
+};
+
+pub const AI_PASSIVE = 0x01;
+pub const AI_CANONNAME = 0x02;
+pub const AI_NUMERICHOST = 0x04;
+pub const AI_V4MAPPED = 0x08;
+pub const AI_ALL = 0x10;
+pub const AI_ADDRCONFIG = 0x20;
+pub const AI_NUMERICSERV = 0x400;
+
+pub const NI_NUMERICHOST = 0x01;
+pub const NI_NUMERICSERV = 0x02;
+pub const NI_NOFQDN = 0x04;
+pub const NI_NAMEREQD = 0x08;
+pub const NI_DGRAM = 0x10;
+pub const NI_NUMERICSCOPE = 0x100;
+
+pub const EAI_BADFLAGS = -1;
+pub const EAI_NONAME = -2;
+pub const EAI_AGAIN = -3;
+pub const EAI_FAIL = -4;
+pub const EAI_FAMILY = -6;
+pub const EAI_SOCKTYPE = -7;
+pub const EAI_SERVICE = -8;
+pub const EAI_MEMORY = -10;
+pub const EAI_SYSTEM = -11;
+pub const EAI_OVERFLOW = -12;
+
+pub const EAI_NODATA = -5;
+pub const EAI_ADDRFAMILY = -9;
+pub const EAI_INPROGRESS = -100;
+pub const EAI_CANCELED = -101;
+pub const EAI_NOTCANCELED = -102;
+pub const EAI_ALLDONE = -103;
+pub const EAI_INTR = -104;
+pub const EAI_IDN_ENCODE = -105;
+
+pub const IPPORT_RESERVED = 1024;
+
+pub const IPPROTO_IP = 0;
+pub const IPPROTO_HOPOPTS = 0;
+pub const IPPROTO_ICMP = 1;
+pub const IPPROTO_IGMP = 2;
+pub const IPPROTO_IPIP = 4;
+pub const IPPROTO_TCP = 6;
+pub const IPPROTO_EGP = 8;
+pub const IPPROTO_PUP = 12;
+pub const IPPROTO_UDP = 17;
+pub const IPPROTO_IDP = 22;
+pub const IPPROTO_TP = 29;
+pub const IPPROTO_DCCP = 33;
+pub const IPPROTO_IPV6 = 41;
+pub const IPPROTO_ROUTING = 43;
+pub const IPPROTO_FRAGMENT = 44;
+pub const IPPROTO_RSVP = 46;
+pub const IPPROTO_GRE = 47;
+pub const IPPROTO_ESP = 50;
+pub const IPPROTO_AH = 51;
+pub const IPPROTO_ICMPV6 = 58;
+pub const IPPROTO_NONE = 59;
+pub const IPPROTO_DSTOPTS = 60;
+pub const IPPROTO_MTP = 92;
+pub const IPPROTO_BEETPH = 94;
+pub const IPPROTO_ENCAP = 98;
+pub const IPPROTO_PIM = 103;
+pub const IPPROTO_COMP = 108;
+pub const IPPROTO_SCTP = 132;
+pub const IPPROTO_MH = 135;
+pub const IPPROTO_UDPLITE = 136;
+pub const IPPROTO_MPLS = 137;
+pub const IPPROTO_RAW = 255;
+pub const IPPROTO_MAX = 256;
lib/std/c.zig
@@ -148,3 +148,24 @@ pub extern "c" fn kevent(
nevents: c_int,
timeout: ?*const timespec,
) c_int;
+
+pub extern "c" fn getaddrinfo(
+ noalias node: [*]const u8,
+ noalias service: [*]const u8,
+ noalias hints: *const addrinfo,
+ noalias res: **addrinfo,
+) c_int;
+
+pub extern "c" fn freeaddrinfo(res: *addrinfo) void;
+
+pub extern "c" fn getnameinfo(
+ noalias addr: *const sockaddr,
+ addrlen: socklen_t,
+ noalias host: [*]u8,
+ hostlen: socklen_t,
+ noalias serv: [*]u8,
+ servlen: socklen_t,
+ flags: u32,
+) c_int;
+
+pub extern "c" fn gai_strerror(errcode: c_int) [*]const u8;
lib/std/net.zig
@@ -11,10 +11,12 @@ pub const TmpWinAddr = struct {
};
pub const OsAddress = switch (builtin.os) {
- builtin.Os.windows => TmpWinAddr,
+ .windows => TmpWinAddr,
else => os.sockaddr,
};
+/// This data structure is a "view". The underlying data might have references
+/// to owned memory which must live longer than this struct.
pub const Address = struct {
os_addr: OsAddress,
@@ -31,7 +33,7 @@ pub const Address = struct {
};
}
- pub fn initIp6(ip6: *const Ip6Addr, _port: u16) Address {
+ pub fn initIp6(ip6: Ip6Addr, _port: u16) Address {
return Address{
.os_addr = os.sockaddr{
.in6 = os.sockaddr_in6{
@@ -53,18 +55,89 @@ pub const Address = struct {
return Address{ .os_addr = addr };
}
- pub fn format(self: *const Address, out_stream: var) !void {
+ pub fn format(
+ self: Address,
+ comptime fmt: []const u8,
+ options: std.fmt.FormatOptions,
+ context: var,
+ comptime Errors: type,
+ output: fn (@typeOf(context), []const u8) Errors!void,
+ ) !void {
switch (self.os_addr.in.family) {
os.AF_INET => {
const native_endian_port = mem.bigToNative(u16, self.os_addr.in.port);
- const bytes = ([]const u8)((*self.os_addr.in.addr)[0..1]);
- try out_stream.print("{}.{}.{}.{}:{}", bytes[0], bytes[1], bytes[2], bytes[3], native_endian_port);
+ const bytes = @ptrCast(*const [4]u8, &self.os_addr.in.addr);
+ try std.fmt.format(
+ context,
+ Errors,
+ output,
+ "{}.{}.{}.{}:{}",
+ bytes[0],
+ bytes[1],
+ bytes[2],
+ bytes[3],
+ native_endian_port,
+ );
},
os.AF_INET6 => {
+ const ZeroRun = struct {
+ index: usize,
+ count: usize,
+ };
const native_endian_port = mem.bigToNative(u16, self.os_addr.in6.port);
- try out_stream.print("[TODO render ip6 address]:{}", native_endian_port);
+ const big_endian_parts = &self.os_addr.in6.addr;
+ const native_endian_parts = switch (builtin.endian) {
+ .Big => big_endian_parts,
+ .Little => blk: {
+ var buf: [8]u16 = undefined;
+ for (big_endian_parts) |part, i| {
+ buf[i] = mem.bigToNative(u16, part);
+ }
+ break :blk buf;
+ },
+ };
+
+ var longest_zero_run: ?ZeroRun = null;
+ var this_zero_run: ?ZeroRun = null;
+ for (native_endian_parts) |part, i| {
+ if (part == 0) {
+ if (this_zero_run) |*zr| {
+ zr.count += 1;
+ } else {
+ this_zero_run = ZeroRun{
+ .index = i,
+ .count = 1,
+ };
+ }
+ } else if (this_zero_run) |zr| {
+ if (longest_zero_run) |lzr| {
+ if (zr.count > lzr.count and zr.count > 1) {
+ longest_zero_run = zr;
+ }
+ } else {
+ longest_zero_run = zr;
+ }
+ }
+ }
+ try output(context, "[");
+ var i: usize = 0;
+ while (i < native_endian_parts.len) {
+ if (i != 0) try output(context, ":");
+
+ if (longest_zero_run) |lzr| {
+ if (lzr.index == i) {
+ i += lzr.count;
+ continue;
+ }
+ }
+
+ const part = native_endian_parts[i];
+ try std.fmt.format(context, Errors, output, "{x}", part);
+ i += 1;
+ }
+ try std.fmt.format(context, Errors, output, "]:{}", native_endian_port);
},
- else => try out_stream.write("(unrecognized address family)"),
+ else => return output(context, "(unrecognized address family)"),
}
}
};
@@ -111,13 +184,13 @@ pub fn parseIp4(buf: []const u8) !u32 {
pub const Ip6Addr = struct {
scope_id: u32,
- addr: [16]u8,
+ addr: [8]u16,
};
pub fn parseIp6(buf: []const u8) !Ip6Addr {
var result: Ip6Addr = undefined;
result.scope_id = 0;
- const ip_slice = result.addr[0..];
+ const ip_slice = @sliceToBytes(result.addr[0..]);
var x: u16 = 0;
var saw_any_digits = false;
@@ -210,10 +283,11 @@ fn testParseIp4Fail(buf: []const u8, expected_err: anyerror) void {
}
test "std.net.parseIp6" {
- const addr = try parseIp6("FF01:0:0:0:0:0:0:FB");
- assert(addr.addr[0] == 0xff);
- assert(addr.addr[1] == 0x01);
- assert(addr.addr[2] == 0x00);
+ const ip6 = try parseIp6("FF01:0:0:0:0:0:0:FB");
+ const addr = Address.initIp6(ip6, 80);
+ var buf: [100]u8 = undefined;
+ const printed = try std.fmt.bufPrint(&buf, "{}", addr);
+ std.testing.expect(mem.eql(u8, "[ff01::fb]:80", printed));
}
pub fn connectUnixSocket(path: []const u8) !std.fs.File {
@@ -245,3 +319,107 @@ pub fn connectUnixSocket(path: []const u8) !std.fs.File {
return std.fs.File.openHandle(sockfd);
}
+
+pub const AddressList = struct {
+ arena: std.heap.ArenaAllocator,
+ addrs: []Address,
+ canon_names: []?[]u8,
+
+ 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
+ }
+};
+
+/// Call `AddressList.deinit` on the result.
+pub fn getAddressList(allocator: *mem.Allocator, name: []const u8, port: u16) !*AddressList {
+ if (builtin.link_libc) {
+ const hints = os.addrinfo{
+ .flags = os.AI_NUMERICSERV,
+ .family = os.AF_UNSPEC,
+ .socktype = os.SOCK_STREAM,
+ .protocol = os.IPPROTO_TCP,
+ .canonname = null,
+ .addr = null,
+ .addrlen = 0,
+ .next = null,
+ };
+ 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_names = undefined,
+ };
+ break :blk result;
+ };
+ const arena = &result.arena.allocator;
+ errdefer result.arena.deinit();
+
+ const name_c = try std.cstr.addNullByte(allocator, name);
+ defer allocator.free(name_c);
+
+ const port_c = try std.fmt.allocPrint(allocator, "{}\x00", port);
+ defer allocator.free(port_c);
+
+ var res: *os.addrinfo = undefined;
+ switch (os.system.getaddrinfo(name_c.ptr, port_c.ptr, &hints, &res)) {
+ 0 => {},
+ os.EAI_ADDRFAMILY => return error.HostLacksNetworkAddresses,
+ os.EAI_AGAIN => return error.TemporaryNameServerFailure,
+ os.EAI_BADFLAGS => unreachable, // Invalid hints
+ os.EAI_FAIL => return error.NameServerFailure,
+ os.EAI_FAMILY => return error.AddressFamilyNotSupported,
+ os.EAI_MEMORY => return error.OutOfMemory,
+ os.EAI_NODATA => return error.HostLacksNetworkAddresses,
+ // The node or service is not known; or both node and service are NULL; or AI_NUMERICSERV
+ // was specified in hints.ai_flags and service was not a numeric port-number string.
+ os.EAI_NONAME => unreachable, // Invalid hints
+ os.EAI_SERVICE => return error.ServiceUnavailable,
+ os.EAI_SOCKTYPE => unreachable, // Invalid socket type requested in hints
+ os.EAI_SYSTEM => switch (os.errno(-1)) {
+ else => |e| return os.unexpectedErrno(e),
+ },
+ else => unreachable,
+ }
+ defer os.system.freeaddrinfo(res);
+
+ const addr_count = blk: {
+ var count: usize = 0;
+ var it: ?*os.addrinfo = res;
+ while (it) |info| : (it = info.next) {
+ if (info.addr != null) {
+ count += 1;
+ }
+ }
+ break :blk count;
+ };
+ result.addrs = try arena.alloc(Address, addr_count);
+ result.canon_names = try arena.alloc(?[]u8, addr_count);
+
+ var it: ?*os.addrinfo = res;
+ var i: usize = 0;
+ while (it) |info| : (it = info.next) {
+ const addr = info.addr orelse continue;
+ result.addrs[i] = std.net.Address.initPosix(addr.*);
+ result.canon_names[i] = null;
+
+ if (info.canonname) |n| {
+ const name_len = mem.len(u8, n);
+ const new_slice = try arena.alloc(u8, name_len + 1);
+ @memcpy(new_slice.ptr, n, name_len + 1);
+ result.canon_names[i] = new_slice[0..name_len];
+ }
+ i += 1;
+ }
+
+ return result;
+ }
+ @compileError("TODO implement std.net.getAddresses for this OS");
+}
src-self-hosted/translate_c.zig
@@ -151,18 +151,22 @@ pub fn translate(
};
defer ZigClangASTUnit_delete(ast_unit);
- var tree_arena = std.heap.ArenaAllocator.init(backing_allocator);
- errdefer tree_arena.deinit();
-
- const tree = try tree_arena.allocator.create(ast.Tree);
- tree.* = ast.Tree{
- .source = undefined, // need to use Buffer.toOwnedSlice later
- .root_node = undefined,
- .arena_allocator = tree_arena,
- .tokens = undefined, // can't reference the allocator yet
- .errors = undefined, // can't reference the allocator yet
+ const tree = blk: {
+ var tree_arena = std.heap.ArenaAllocator.init(backing_allocator);
+ errdefer tree_arena.deinit();
+
+ const tree = try tree_arena.allocator.create(ast.Tree);
+ tree.* = ast.Tree{
+ .source = undefined, // need to use Buffer.toOwnedSlice later
+ .root_node = undefined,
+ .arena_allocator = tree_arena,
+ .tokens = undefined, // can't reference the allocator yet
+ .errors = undefined, // can't reference the allocator yet
+ };
+ break :blk tree;
};
const arena = &tree.arena_allocator.allocator; // now we can reference the allocator
+ errdefer arena.deinit();
tree.tokens = ast.Tree.TokenList.init(arena);
tree.errors = ast.Tree.ErrorList.init(arena);