Commit 22888ca524
Changed files (6)
src/analyze.cpp
@@ -4260,6 +4260,7 @@ static TypeTableEntry *analyze_cast_expr(CodeGen *g, ImportTableEntry *import, B
(wanted_type->data.structure.fields[0].type_entry->data.pointer.is_const ||
!actual_type->data.structure.fields[0].type_entry->data.pointer.is_const))
{
+ mark_impure_fn(context);
return resolve_cast(g, context, node, expr_node, wanted_type, CastOpResizeSlice, true);
}
std/hash_map.zig
@@ -6,6 +6,12 @@ const Allocator = mem.Allocator;
const want_modification_safety = !@compile_var("is_release");
const debug_u32 = if (want_modification_safety) u32 else void;
+/*
+pub fn HashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b: K)->bool) {
+ SmallHashMap(K, V, hash, eql, 8);
+}
+*/
+
pub struct SmallHashMap(K: type, V: type, hash: fn(key: K)->u32, eql: fn(a: K, b: K)->bool, STATIC_SIZE: isize) {
entries: []Entry,
size: isize,
std/index.zig
@@ -12,4 +12,3 @@ pub const mem = @import("mem.zig");
pub fn assert(b: bool) {
if (!b) unreachable{}
}
-
std/linux.zig
@@ -312,13 +312,10 @@ fn restore_signals(set: &sigset_t) {
}
-pub type sa_family_t = u16;
-pub type socklen_t = u32;
-pub type in_addr_t = u32;
-
-export struct in_addr {
- s_addr: in_addr_t,
-}
+pub const sa_family_t = u16;
+pub const socklen_t = u32;
+pub const in_addr = u32;
+pub const in6_addr = [16]u8;
export struct sockaddr {
family: sa_family_t,
@@ -341,15 +338,33 @@ export struct sockaddr_in6 {
scope_id: u32,
}
-export struct in6_addr {
- addr: [16]u8,
-}
-
export struct iovec {
iov_base: &u8,
iov_len: usize,
}
+/*
+const IF_NAMESIZE = 16;
+
+export struct ifreq {
+ ifrn_name: [IF_NAMESIZE]u8,
+ union {
+ ifru_addr: sockaddr,
+ ifru_dstaddr: sockaddr,
+ ifru_broadaddr: sockaddr,
+ ifru_netmask: sockaddr,
+ ifru_hwaddr: sockaddr,
+ ifru_flags: i16,
+ ifru_ivalue: i32,
+ ifru_mtu: i32,
+ ifru_map: ifmap,
+ ifru_slave: [IF_NAMESIZE]u8,
+ ifru_newname: [IF_NAMESIZE]u8,
+ ifru_data: &u8,
+ } ifr_ifru;
+}
+*/
+
pub fn getsockname(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t) -> isize {
arch.syscall3(arch.SYS_getsockname, fd, isize(addr), isize(len))
}
@@ -415,3 +430,33 @@ pub fn socketpair(domain: i32, socket_type: i32, protocol: i32, fd: [2]i32) -> i
pub fn accept4(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t, flags: i32) -> isize {
arch.syscall4(arch.SYS_accept4, fd, isize(addr), isize(len), flags)
}
+
+/*
+pub error NameTooLong;
+pub error SystemResources;
+pub error Io;
+
+pub fn if_nametoindex(name: []u8) -> %u32 {
+ var ifr: ifreq = undefined;
+
+ if (name.len >= ifr.ifr_name.len) {
+ return error.NameTooLong;
+ }
+
+ const socket_ret = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
+ const socket_err = get_errno(socket_ret);
+ if (socket_err > 0) {
+ return error.SystemResources;
+ }
+ const socket_fd = i32(socket_ret);
+ @memcpy(&ifr.ifr_name[0], &name[0], name.len);
+ ifr.ifr_name[name.len] = 0;
+ const ioctl_ret = ioctl(socket_fd, SIOCGIFINDEX, &ifr);
+ close(socket_fd);
+ const ioctl_err = get_errno(ioctl_ret);
+ if (ioctl_err > 0) {
+ return error.Io;
+ }
+ return ifr.ifr_ifindex;
+}
+*/
std/list.zig
@@ -3,8 +3,8 @@ const mem = @import("mem.zig");
const Allocator = mem.Allocator;
/*
-fn List(T: type) -> type {
- List(T, 8)
+pub fn List(T: type) -> type {
+ SmallList(T, 8)
}
*/
std/net.zig
@@ -1,9 +1,11 @@
const linux = @import("linux.zig");
const errno = @import("errno.zig");
+const assert = @import("index.zig").assert;
pub error SigInterrupt;
pub error Unexpected;
pub error Io;
+pub error TimedOut;
struct Connection {
socket_fd: i32,
@@ -20,17 +22,37 @@ struct Connection {
}
struct Address {
- addr: linux.sockaddr,
+ family: u16,
+ scope_id: u32,
+ addr: [16]u8,
+ sort_key: i32,
}
pub fn lookup(hostname: []const u8, out_addrs: []Address) -> %[]Address {
+ if (hostname.len == 0) {
+
+/*
+ if (family != AF_INET6)
+ buf[cnt++] = (struct address){ .family = AF_INET, .addr = { 127,0,0,1 } };
+ if (family != AF_INET)
+ buf[cnt++] = (struct address){ .family = AF_INET6, .addr = { [15] = 1 } };
+ */
+ unreachable{} // TODO
+ }
+
+ switch (parse_ip_literal(hostname)) {
+ Ok => |addr| {
+ out_addrs[0] = addr;
+ return out_addrs[0...1];
+ },
+ else => {},
+ };
+
unreachable{} // TODO
}
pub fn connect_addr(addr: &Address, port: u16) -> %Connection {
- addr.addr.port = port;
-
- const socket_ret = linux.socket(linux.PF_INET, linux.SOCK_STREAM, linux.PROTO_tcp);
+ const socket_ret = linux.socket(addr.family, linux.SOCK_STREAM, linux.PROTO_tcp);
const socket_err = linux.get_errno(socket_ret);
if (socket_err > 0) {
// TODO figure out possible errors from socket()
@@ -38,10 +60,33 @@ pub fn connect_addr(addr: &Address, port: u16) -> %Connection {
}
const socket_fd = i32(socket_ret);
- const connect_err = linux.get_errno(linux.connect(socket_fd, &addr.addr, @sizeof(linux.sockaddr)));
+ const connect_ret = if (addr.family == linux.AF_INET) {
+ var os_addr: linux.sockaddr_in = undefined;
+ os_addr.family = addr.family;
+ os_addr.port = host_to_be(u16)(port);
+ @memcpy((&u8)(&os_addr.addr), &addr.addr[0], 4);
+ @memset(&os_addr.zero, 0, @sizeof(@typeof(os_addr.zero)));
+ linux.connect(socket_fd, (&linux.sockaddr)(&os_addr), @sizeof(linux.sockaddr_in))
+ } else if (addr.family == linux.AF_INET6) {
+ var os_addr: linux.sockaddr_in6 = undefined;
+ os_addr.family = addr.family;
+ os_addr.port = host_to_be(u16)(port);
+ os_addr.flowinfo = 0;
+ os_addr.scope_id = addr.scope_id;
+ @memcpy(&os_addr.addr[0], &addr.addr[0], 16);
+ linux.connect(socket_fd, (&linux.sockaddr)(&os_addr), @sizeof(linux.sockaddr_in6))
+ } else {
+ unreachable{}
+ };
+ const connect_err = linux.get_errno(connect_ret);
if (connect_err > 0) {
- // TODO figure out possible errors from connect()
- return error.Unexpected;
+ switch (connect_err) {
+ errno.ETIMEDOUT => return error.TimedOut,
+ else => {
+ // TODO figure out possible errors from connect()
+ return error.Unexpected;
+ },
+ }
}
return Connection {
@@ -56,3 +101,232 @@ pub fn connect(hostname: []const u8, port: u16) -> %Connection {
return connect_addr(main_addr, port);
}
+
+pub error InvalidIpLiteral;
+
+pub fn parse_ip_literal(buf: []const u8) -> %Address {
+ switch (parse_ip4(buf)) {
+ Ok => |ip4| {
+ var result: Address = undefined;
+ @memcpy(&result.addr[0], (&u8)(&ip4), @sizeof(u32));
+ result.family = linux.AF_INET;
+ result.scope_id = 0;
+ return result;
+ },
+ else => {},
+ }
+ switch (parse_ip6(buf)) {
+ Ok => |addr| {
+ return addr;
+ },
+ else => {},
+ }
+
+ return error.InvalidIpLiteral;
+}
+
+fn hex_digit(c: u8) -> u8 {
+ // TODO use switch with range
+ if ('0' <= c && c <= '9') {
+ c - '0'
+ } else if ('A' <= c && c <= 'Z') {
+ c - 'A' + 10
+ } else if ('a' <= c && c <= 'z') {
+ c - 'a' + 10
+ } else {
+ @max_value(u8)
+ }
+}
+
+error InvalidChar;
+error Overflow;
+error JunkAtEnd;
+error Incomplete;
+
+#static_eval_enable(false)
+fn parse_ip6(buf: []const u8) -> %Address {
+ var result: Address = undefined;
+ result.family = linux.AF_INET6;
+ result.scope_id = 0;
+ const ip_slice = result.addr[0...];
+
+ var x: u16 = 0;
+ var saw_any_digits = false;
+ var index: u8 = 0;
+ var scope_id = false;
+ for (buf) |c| {
+ if (scope_id) {
+ if (c >= '0' && c <= '9') {
+ const digit = c - '0';
+ if (@mul_with_overflow(u32, result.scope_id, 10, &result.scope_id)) {
+ return error.Overflow;
+ }
+ if (@add_with_overflow(u32, result.scope_id, digit, &result.scope_id)) {
+ return error.Overflow;
+ }
+ } else {
+ return error.InvalidChar;
+ }
+ } else if (c == ':') {
+ if (!saw_any_digits) {
+ return error.InvalidChar;
+ }
+ if (index == 14) {
+ return error.JunkAtEnd;
+ }
+ ip_slice[index] = @truncate(u8, x >> 8);
+ index += 1;
+ ip_slice[index] = @truncate(u8, x);
+ index += 1;
+
+ x = 0;
+ saw_any_digits = false;
+ } else if (c == '%') {
+ if (!saw_any_digits) {
+ return error.InvalidChar;
+ }
+ if (index == 14) {
+ ip_slice[index] = @truncate(u8, x >> 8);
+ index += 1;
+ ip_slice[index] = @truncate(u8, x);
+ index += 1;
+ }
+ scope_id = true;
+ saw_any_digits = false;
+ } else {
+ const digit = hex_digit(c);
+ if (digit == @max_value(u8)) {
+ return error.InvalidChar;
+ }
+ if (@mul_with_overflow(u16, x, 16, &x)) {
+ return error.Overflow;
+ }
+ if (@add_with_overflow(u16, x, digit, &x)) {
+ return error.Overflow;
+ }
+ saw_any_digits = true;
+ }
+ }
+
+ if (!saw_any_digits) {
+ return error.Incomplete;
+ }
+
+ /*
+ if (p) {
+ if (isdigit(*++p)) scopeid = strtoull(p, &z, 10);
+ else z = p-1;
+ if (*z) {
+ if (!IN6_IS_ADDR_LINKLOCAL(&a6) &&
+ !IN6_IS_ADDR_MC_LINKLOCAL(&a6))
+ return EAI_NONAME;
+ scopeid = if_nametoindex(p);
+ if (!scopeid) return EAI_NONAME;
+ }
+ if (scopeid > UINT_MAX) return EAI_NONAME;
+ }
+ */
+
+ if (scope_id) {
+ return result;
+ }
+
+ if (index == 14) {
+ ip_slice[14] = @truncate(u8, x >> 8);
+ ip_slice[15] = @truncate(u8, x);
+ return result;
+ }
+
+ return error.Incomplete;
+}
+
+fn parse_ip4(buf: []const u8) -> %u32 {
+ var result: u32 = undefined;
+ const out_ptr = ([]u8)((&result)[0...1]);
+
+ var x: u8 = 0;
+ var index: u8 = 0;
+ var saw_any_digits = false;
+ for (buf) |c| {
+ if (c == '.') {
+ if (!saw_any_digits) {
+ return error.InvalidChar;
+ }
+ if (index == 3) {
+ return error.JunkAtEnd;
+ }
+ out_ptr[index] = x;
+ index += 1;
+ x = 0;
+ saw_any_digits = false;
+ } else if (c >= '0' && c <= '9') {
+ saw_any_digits = true;
+ const digit = c - '0';
+ if (@mul_with_overflow(u8, x, 10, &x)) {
+ return error.Overflow;
+ }
+ if (@add_with_overflow(u8, x, digit, &x)) {
+ return error.Overflow;
+ }
+ } else {
+ return error.InvalidChar;
+ }
+ }
+ if (index == 3 && saw_any_digits) {
+ out_ptr[index] = x;
+ return result;
+ }
+
+ return error.Incomplete;
+}
+
+
+#attribute("test")
+fn test_parse_ip4() {
+ assert(%%parse_ip4("127.0.0.1") == be_to_host(u32)(0x7f000001));
+ switch (parse_ip4("256.0.0.1")) { Overflow => {}, else => unreachable {}, }
+ switch (parse_ip4("x.0.0.1")) { InvalidChar => {}, else => unreachable {}, }
+ switch (parse_ip4("127.0.0.1.1")) { JunkAtEnd => {}, else => unreachable {}, }
+ switch (parse_ip4("127.0.0.")) { Incomplete => {}, else => unreachable {}, }
+ switch (parse_ip4("100..0.1")) { InvalidChar => {}, else => unreachable {}, }
+}
+
+#attribute("test")
+fn test_parse_ip6() {
+ {
+ const addr = %%parse_ip6("FF01:0:0:0:0:0:0:FB");
+ assert(addr.addr[0] == 0xff);
+ assert(addr.addr[1] == 0x01);
+ assert(addr.addr[2] == 0x00);
+ }
+}
+
+#attribute("test")
+fn test_lookup_simple_ip() {
+ {
+ var addrs_buf: [5]Address = undefined;
+ const addrs = %%lookup("192.168.1.1", addrs_buf);
+ assert(addrs.len == 1);
+ const addr = addrs[0];
+ assert(addr.family == linux.AF_INET);
+ assert(addr.addr[0] == 192);
+ assert(addr.addr[1] == 168);
+ assert(addr.addr[2] == 1);
+ assert(addr.addr[3] == 1);
+ }
+}
+
+const be_to_host = host_to_be;
+fn host_to_be(T: type)(x: T) -> T {
+ if (@compile_var("is_big_endian")) x else endian_swap(T)(x)
+}
+
+fn endian_swap(T: type)(x: T) -> T {
+ const x_slice = ([]u8)((&const x)[0...1]);
+ var result: T = undefined;
+ const result_slice = ([]u8)((&result)[0...1]);
+ for (result_slice) |*b, i| {
+ *b = x_slice[@sizeof(T) - i - 1];
+ }
+ return result;
+}