0.6.0 --- adopt openkal 0.9, and ask this machine what its page is

⚠️⚠️ THE ALLOCATOR ASSUMED A FOUR-KILOBYTE PAGE ON A SYSTEM WITH TWO.

`kPage' was the constant 4096, and this system's own hardware pages are four
kilobytes on one architecture and SIXTEEN on the other. Allocation appeared to
work, because a mapping rounded to four kilobytes is rounded up again by the
kernel --- while `kal_free' unmapped a range SHORTER than the one mapped, and
the remainder was never returned. The page is now asked for once, through
`hw.pagesize', and `kal_memory_granularity' reports it.

The rest follows the specification:

  * `kal_fs_props' takes the directory and consults the format the volume is,
    which this kernel names in words. A word per implementation could state
    none of its positions honestly here: the volume this system is ordinarily
    installed on compares names without regard to case and a volume attached to
    the same machine may not, and both are reachable through the preopen this
    implementation supplies;
  * asking now resolves a link, because opening always did;
  * transfers return one signed word; the parameters and names are copied into
    the caller's buffer and the length reported is the value's own;
  * `kal_node_info' carries its own size, reports what was filled, and carries
    the device and inode as an opaque identity;
  * `kal_fs_link_create' and `kal_fs_link_read' over symlinkat and readlinkat;
  * `kal_fs_max_name'; typed stream handles; `kal_version' and
    `kal_interfaces'.

Ninety-five names are exported and none other, checked against SURFACE.txt.

Author: speak-agent

mcpp.toml

@@ -1,7 +1,7 @@
 [package]
 namespace   = "mcpplibs"
 name        = "openkal-macos"
-version     = "0.5.0"
+version     = "0.6.0"
 description = "An implementation of openkal for macOS, written on the kernel's own calls. Its purpose is as much to test the specification as to be used."
 license     = "Apache-2.0"
 
@@ -18,7 +18,7 @@ authors     = ["mcpplibs"]
 repo        = "https://github.com/mcpplibs/openkal-macos"
 
 [dependencies]
-openkal = "0.8.0"
+openkal = "0.9.0"
 
 [build]
 # The flags are attached to this package's own sources rather than to the whole

src/datagram.cpp

@@ -72,15 +72,15 @@ int kal_datagram_local(kal_datagram d, kal_endpoint* out) {
     return okm::from_kernel(ss, *out);
 }
 
-kal_io_result kal_datagram_send_to(kal_datagram d, const void* buf, kal_uintptr len,
-                                   const kal_endpoint* to) {
+kal_intptr kal_datagram_send_to(kal_datagram d, const void* buf, kal_uintptr len,
+                                const kal_endpoint* to) {
     const int fd = fd_of(d);
-    if (fd < 0 || to == nullptr) return { 0, kal_err_invalid };
+    if (fd < 0 || to == nullptr) return -kal_err_invalid;
 
     okm::ksockaddr_storage ss{};
     okm_u32 addrlen = 0;
     if (const int rc = okm::to_kernel(*to, ss, addrlen); rc != kal_ok)
-        return { 0, rc };
+        return -rc;
 
     for (;;) {
         const okm_long r = okm::sys(okm::nr_sendto, fd,
@@ -89,7 +89,7 @@ kal_io_result kal_datagram_send_to(kal_datagram d, const void* buf, kal_uintptr
                                     reinterpret_cast<okm_long>(&ss),
                                     static_cast<okm_long>(addrlen));
         if (okm::interrupted(r)) continue;
-        if (okm::failed(r)) return { 0, okm::translate(r) };
+        if (okm::failed(r)) return -okm::translate(r);
 
         // A MESSAGE IS SENT WHOLE OR NOT AT ALL, which is what this interface
         // states. The kernel reports a count anyway; a count short of the length
@@ -98,14 +98,14 @@ kal_io_result kal_datagram_send_to(kal_datagram d, const void* buf, kal_uintptr
         // a caller a partial send this interface says cannot occur, so it is
         // reported as a failure of the medium instead.
         const kal_uintptr n = static_cast<kal_uintptr>(r);
-        return { n, n == len ? kal_ok : kal_err_io };
+        return n == len ? static_cast<kal_intptr>(n) : -kal_err_io;
     }
 }
 
-kal_io_result kal_datagram_recv_from(kal_datagram d, void* buf, kal_uintptr len,
-                                     kal_endpoint* from) {
+kal_intptr kal_datagram_recv_from(kal_datagram d, void* buf, kal_uintptr len,
+                                  kal_endpoint* from) {
     const int fd = fd_of(d);
-    if (fd < 0) return { 0, kal_err_invalid };
+    if (fd < 0) return -kal_err_invalid;
 
     okm::ksockaddr_storage ss{};
     okm_u32 addrlen = static_cast<okm_u32>(sizeof ss);
@@ -117,7 +117,7 @@ kal_io_result kal_datagram_recv_from(kal_datagram d, void* buf, kal_uintptr len,
                                     reinterpret_cast<okm_long>(&ss),
                                     reinterpret_cast<okm_long>(&addrlen));
         if (okm::interrupted(r)) continue;
-        if (okm::failed(r)) return { 0, okm::translate(r) };
+        if (okm::failed(r)) return -okm::translate(r);
 
         // THE COUNT REPORTED IS WHAT WAS PLACED IN THE BUFFER, not what was
         // sent. Without MSG_TRUNC the kernel already reports the former, which
@@ -133,7 +133,7 @@ kal_io_result kal_datagram_recv_from(kal_datagram d, void* buf, kal_uintptr len,
                 from->port     = 0;
             }
         }
-        return { static_cast<kal_uintptr>(r), kal_ok };
+        return static_cast<kal_intptr>(r);
     }
 }
 
@@ -148,6 +148,6 @@ void kal_datagram_close(kal_datagram d) {
 // been set, and this interface has no operation that would set it; a word
 // claiming a facility no operation reaches is the disagreement clause 6.2 exists
 // to prevent.
-const kal_uintptr kal_datagram_props = KAL_DGRAM_PROP_IPV6;
+kal_uintptr kal_datagram_props(void) { return KAL_DGRAM_PROP_IPV6; }
 
 }  // extern "C"

src/env.cpp

@@ -27,46 +27,56 @@ extern "C" {
 
 kal_uintptr kal_env_arg_count(void) { return static_cast<kal_uintptr>(okm::g_argc); }
 
-const char* kal_env_arg(kal_uintptr index, kal_uintptr* len) {
-    if (index >= static_cast<kal_uintptr>(okm::g_argc)) { if (len) *len = 0; return nullptr; }
+// EVERY VALUE IS COPIED INTO THE CALLER'S BUFFER. These answered with a pointer
+// into this implementation's own storage, which is meaningful only while the
+// implementation shares the caller's address space. Each reports the length the
+// value HAS, so a caller with a large enough buffer is done in one call and one
+// that wants to size first passes a capacity of zero.
+namespace {
+kal_intptr give(const char* v, kal_uintptr n, char* out, kal_uintptr cap) {
+    if (out != nullptr && cap != 0) okm::copy(out, v, n < cap ? n : cap);
+    return static_cast<kal_intptr>(n);
+}
+}  // namespace
+
+kal_intptr kal_env_arg(kal_uintptr index, char* out, kal_uintptr cap) {
+    if (index >= static_cast<kal_uintptr>(okm::g_argc)) return -kal_err_not_found;
     const char* s = okm::g_argv[index];
-    if (len) *len = okm::length(s);
-    return s;
+    return give(s, okm::length(s), out, cap);
 }
 
-const char* kal_env_var(const char* name, kal_uintptr name_len, kal_uintptr* value_len) {
+kal_intptr kal_env_var(const char* name, kal_uintptr name_len,
+                       char* out, kal_uintptr cap) {
+    if (name == nullptr) return -kal_err_invalid;
     for (char** e = okm::g_envp; e && *e; ++e) {
         const char* entry = *e;
         kal_uintptr i = 0;
         while (i < name_len && entry[i] != '\0' && entry[i] == name[i]) ++i;
         if (i == name_len && entry[i] == '=') {
             const char* v = entry + name_len + 1;
-            if (value_len) *value_len = okm::length(v);
-            return v;
+            return give(v, okm::length(v), out, cap);
         }
     }
-    if (value_len) *value_len = 0;
-    return nullptr;
+    // A name that is not there is distinct from one whose value is empty.
+    return -kal_err_not_found;
 }
 
 kal_uintptr kal_env_var_count(void) {
     kal_uintptr n = 0; for (char** e = okm::g_envp; e && *e; ++e) ++n; return n;
 }
 
-const char* kal_env_var_at(kal_uintptr index, kal_uintptr* name_len,
-                           const char** value, kal_uintptr* value_len) {
+// The NAME at a position. The value is then obtained by kal_env_var: an
+// operation answering both needs two buffers, two capacities and two lengths,
+// and its second half is kal_env_var written again.
+kal_intptr kal_env_var_at(kal_uintptr index, char* out, kal_uintptr cap) {
     kal_uintptr n = 0;
     for (char** e = okm::g_envp; e && *e; ++e, ++n) {
         if (n != index) continue;
         const char* entry = *e;
         kal_uintptr i = 0; while (entry[i] != '\0' && entry[i] != '=') ++i;
-        if (name_len) *name_len = i;
-        const char* v = entry[i] == '=' ? entry + i + 1 : entry + i;
-        if (value)     *value = v;
-        if (value_len) *value_len = okm::length(v);
-        return entry;
+        return give(entry, i, out, cap);
     }
-    return nullptr;
+    return -kal_err_not_found;
 }
 
 }

src/exec.cpp

@@ -120,6 +120,11 @@ void kal_exec_free(void* p, kal_uintptr size) {
 // interface separates the two states; a caller that must change published bytes
 // reserves a second region and abandons the first, which is what the header
 // says a zero here means.
-const kal_uintptr kal_exec_props = 0;
+// Executable memory on this system is granted only to an artifact produced
+// with the entitlement for it, which is a decision made after the link. The
+// interface is provided and the position reports whether this artifact may use
+// it --- clause 6.5's answer at dependency resolution cannot serve an artifact
+// produced once and run in many environments.
+kal_uintptr kal_exec_props(void) { return 0; }
 
 }  // extern "C"