Reach the network at run time: its names are the C library's names

⚠️⚠️ THIS SYSTEM'S NETWORK LIBRARY EXPORTS THE BSD NAMES, AND SO DOES THE
C LIBRARY ABOVE THIS IMPLEMENTATION. openkal-musl compiles musl's own
`src/network/*.c', which define `bind', `listen', `accept' and `connect'
and route them through this port. Naming `-lws2_32' on the link line put
both definitions in one program:

    ld.exe: libws2_32.a(libws2_32s00165.o): multiple definition of
            `connect'; musl/src/network/connect.o: first defined here

Measured on the GNU/PE row of the C library's own continuous integration,
on the first run of this change. It is not an ordering problem: an import
library's member defines the thunk AND the `__imp_' pointer together, so
reaching for either brings both.

⭐ THE NAMES ARE THEREFORE REACHED THROUGH THE SYSTEM'S OWN LOADER
--- `LoadLibraryW' and `GetProcAddress', both of which this package
already links --- into a table resolved once. Nothing of ws2_32 enters
the program's symbol table, so the C library above keeps its `bind' and
this implementation still reaches the system's.

`port/ws2_32.def', the `-lws2_32' flag and the `#pragma comment' all come
out. The table is resolved ENTIRELY OR NOT AT ALL: a table with one null
entry would make the operations that resolved work and the one that did
not call through zero, which is the failure clause 6.1 exists to turn
into a link error and this arrangement cannot.

Measured here after the change: `examples/cross-hello' links and produces
`cross-hello.exe' over this implementation and that C library; 16
objects; exported surface complete and conforming at 88 names; no
undefined symbol outside the permitted set; and NO BSD NAME DEFINED in
this package's own objects, which is the property the collision was about.

Author: speak-agent

build.mcpp

@@ -117,7 +117,6 @@ int main() {
     mcpp::rerun_if_changed("port/shell32.def");
     mcpp::rerun_if_changed("port/synchronization.def");
     mcpp::rerun_if_changed("port/bcrypt.def");
-    mcpp::rerun_if_changed("port/ws2_32.def");
 
     if (host_is_windows()) return 0;
 
@@ -140,7 +139,7 @@ int main() {
     const std::string tool = dlltool();
 
     for (auto name : { "kernel32", "ntdll", "shell32", "synchronization",
-                       "bcrypt", "ws2_32" }) {
+                       "bcrypt" }) {
         const auto def = std::format("{}/port/{}.def", root, name);
         const auto lib = std::format("{}/lib{}.a", out, name);
         // ⚠️ `-m i386:x86-64` is stated. See port/README.md: the 32-bit ABI

mcpp.toml

@@ -49,8 +49,7 @@ openkal = "0.8.0"
 # predicate the second one linked with none of these libraries and failed on
 # `GetStdHandle`.
 [target.'cfg(all(windows, not(env = "msvc")))'.build]
-ldflags = ["-lntdll", "-lsynchronization", "-lshell32", "-lkernel32", "-lbcrypt",
-           "-lws2_32"]
+ldflags = ["-lntdll", "-lsynchronization", "-lshell32", "-lkernel32", "-lbcrypt"]
 
 # Exceptions and run-time type information, on the one ABI where their absence
 # is asserted.

port/kernel32.def

@@ -23,11 +23,13 @@ GetFileType
 GetFinalPathNameByHandleW
 GetLastError
 GetLogicalDriveStringsW
+GetProcAddress
 GetProcessHeap
 GetStdHandle
 GetSystemTimePreciseAsFileTime
 HeapAlloc
 HeapFree
+LoadLibraryW
 LocalFree
 MultiByteToWideChar
 QueryPerformanceCounter

port/ws2_32.def

@@ -14,6 +14,8 @@ namespace {
 
 SOCKET socket_of(kal_datagram d) { return okw::unpack_socket(d.h); }
 
+okw::network_calls* net() { return okw::net_or_null(); }
+
 bool bad(SOCKET s) { return s == INVALID_SOCKET; }
 
 // The largest transfer one call accepts. This system states a count as an
@@ -38,26 +40,27 @@ int kal_datagram_open(const kal_endpoint* local, kal_datagram* out) {
         if (family < 0) return kal_err_invalid;
     }
 
-    okw::ensure_network();
-    const SOCKET s = WSASocketW(family, SOCK_DGRAM_, IPPROTO_UDP_, nullptr, 0, 0);
+    auto* n = net();
+    if (n == nullptr) return kal_err_io;
+    const SOCKET s = n->socket(family, SOCK_DGRAM_, IPPROTO_UDP_, nullptr, 0, 0);
     if (bad(s)) return okw::last_socket_error();
 
     if (local != nullptr) {
         ksockaddr_storage ss{};
         int len = 0;
         if (const int rc = okw::to_system(*local, ss, len); rc != kal_ok) {
-            closesocket(s);
+            n->close(s);
             return rc;
         }
-        if (bind(s, &ss, len) != 0) {
+        if (n->bind(s, &ss, len) != 0) {
             const int e = okw::last_socket_error();
-            closesocket(s);
+            n->close(s);
             return e;
         }
     }
 
     out->h = okw::pack_socket(s);
-    if (out->h == 0) { closesocket(s); return kal_err_no_memory; }
+    if (out->h == 0) { n->close(s); return kal_err_no_memory; }
     return kal_ok;
 }
 
@@ -66,9 +69,11 @@ int kal_datagram_local(kal_datagram d, kal_endpoint* out) {
     const SOCKET s = socket_of(d);
     if (bad(s)) return kal_err_invalid;
 
+    auto* n = net();
+    if (n == nullptr) return kal_err_io;
     ksockaddr_storage ss{};
     int len = static_cast<int>(sizeof ss);
-    if (getsockname(s, &ss, &len) != 0) return okw::last_socket_error();
+    if (n->sockname(s, &ss, &len) != 0) return okw::last_socket_error();
     return okw::from_system(ss, *out);
 }
 
@@ -78,13 +83,15 @@ kal_io_result kal_datagram_send_to(kal_datagram d, const void* buf, kal_uintptr
     if (bad(s) || to == nullptr) return { 0, kal_err_invalid };
     if (len > kMaxOne) return { 0, kal_err_invalid };
 
+    auto* n = net();
+    if (n == nullptr) return { 0, kal_err_io };
     ksockaddr_storage ss{};
     int addrlen = 0;
     if (const int rc = okw::to_system(*to, ss, addrlen); rc != kal_ok)
         return { 0, rc };
 
-    const int r = sendto(s, static_cast<const char*>(buf), static_cast<int>(len),
-                         0, &ss, addrlen);
+    const int r = n->send_to(s, static_cast<const char*>(buf), static_cast<int>(len),
+                             0, &ss, addrlen);
     if (r < 0) return { 0, okw::last_socket_error() };
 
     // A MESSAGE IS SENT WHOLE OR NOT AT ALL, which is what this interface
@@ -93,8 +100,8 @@ kal_io_result kal_datagram_send_to(kal_datagram d, const void* buf, kal_uintptr
     // it does not do. Reporting the short count as success would give 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 };
+    const kal_uintptr sent = static_cast<kal_uintptr>(r);
+    return { sent, sent == len ? kal_ok : kal_err_io };
 }
 
 kal_io_result kal_datagram_recv_from(kal_datagram d, void* buf, kal_uintptr len,
@@ -103,11 +110,13 @@ kal_io_result kal_datagram_recv_from(kal_datagram d, void* buf, kal_uintptr len,
     if (bad(s)) return { 0, kal_err_invalid };
     if (len > kMaxOne) len = kMaxOne;
 
+    auto* n = net();
+    if (n == nullptr) return { 0, kal_err_io };
     ksockaddr_storage ss{};
     int addrlen = static_cast<int>(sizeof ss);
 
-    const int r = recvfrom(s, static_cast<char*>(buf), static_cast<int>(len),
-                           0, &ss, &addrlen);
+    const int r = n->recv_from(s, static_cast<char*>(buf), static_cast<int>(len),
+                               0, &ss, &addrlen);
     if (r < 0) {
         // ⚠️ THE ONE FAILURE THIS SYSTEM REPORTS THAT THE OTHER TWO DO NOT.
         //
@@ -122,7 +131,7 @@ kal_io_result kal_datagram_recv_from(kal_datagram d, void* buf, kal_uintptr len,
         //
         // The count is not recoverable from this call, so what is reported is
         // the whole of the buffer, which is what was filled.
-        if (WSAGetLastError() == okw::WSAEMSGSIZE) {
+        if (n->last_error() == okw::WSAEMSGSIZE) {
             if (from != nullptr && okw::from_system(ss, *from) != kal_ok) {
                 for (auto& b : from->addr) b = 0;
                 from->addr_len = 0;
@@ -149,7 +158,7 @@ kal_io_result kal_datagram_recv_from(kal_datagram d, void* buf, kal_uintptr len,
 void kal_datagram_close(kal_datagram d) {
     const SOCKET s = socket_of(d);
     if (bad(s)) return;
-    closesocket(s);
+    if (auto* n = net()) n->close(s);
     okw::retire(d.h);
 }
 

src/datagram.cpp

@@ -57,32 +57,115 @@ inline int translate_wsa(int e) {
     }
 }
 
-inline int last_socket_error() { return translate_wsa(WSAGetLastError()); }
-
-// ── starting this system's network interface ────────────────────────────────
+// ── reaching this system's network interface ────────────────────────────────
+//
+// ⚠️⚠️ RESOLVED AT RUN TIME RATHER THAN LINKED, AND src/win32.h RECORDS THE
+// MEASUREMENT: this library's names are the BSD names, the C library above this
+// implementation defines the same names, and an import library puts both
+// definitions in one program. Nothing of ws2_32 enters this program's symbol
+// table now.
 //
-// ⚠️ IT HAS TO BE STARTED, AND THERE IS NO OTHER PLACE TO DO IT. Every socket
-// call fails with `WSANOTINITIALISED' until `WSAStartup' has been called in
-// this image, and openkal has no operation a program calls first.
+// ⚠️ IT ALSO HAS TO BE STARTED. Every socket call fails with
+// `WSANOTINITIALISED' until `WSAStartup' has been called in this image, and
+// openkal has no operation a program calls first --- so the first operation
+// that needs the interface starts it.
 //
 // ⭐ NOT A FUNCTION-LOCAL STATIC WITH A RUNTIME INITIALISER, AND THE MANIFEST
 // SAYS WHY: every static in this package is initialised by a constant, so no
 // guard variable is emitted. One with a runtime initialiser would emit a call
 // to `__cxa_guard_acquire' --- a C runtime symbol, in the one package whose
 // continuous integration asserts it references none.
 //
-// ⚠️ THE FLAG IS READ AND WRITTEN WITHOUT SYNCHRONISATION, AND THAT IS SAFE
-// HERE RATHER THAN OVERLOOKED. Two contexts racing produce a second
-// `WSAStartup', which this system reference-counts and which is documented as
-// callable more than once. This implementation never calls `WSACleanup' --- the
-// interface stays started for the life of the image, which is what a program
-// that opened a socket wants --- so the count never reaches zero and the
-// duplicate costs nothing.
-inline void ensure_network() {
-    static int started = 0;
-    if (started) return;
+// ⚠️ THE TABLE IS READ AND WRITTEN WITHOUT SYNCHRONISATION, AND THAT IS SAFE
+// HERE RATHER THAN OVERLOOKED. Two contexts racing resolve the same pointers
+// from the same library to the same values and perform a second `WSAStartup',
+// which this system reference-counts and documents as callable more than once.
+// This implementation never calls `WSACleanup' --- the interface stays
+// available for the life of the image, which is what a program that opened a
+// socket wants --- so the count never reaches zero.
+struct network_calls {
+    int ready;                       // 0 not tried, 1 available, -1 absent
+    pfn_WSAGetLastError last_error;
+    pfn_WSASocketW      socket;
+    pfn_closesocket     close;
+    pfn_bind            bind;
+    pfn_listen          listen;
+    pfn_accept          accept;
+    pfn_connect         connect;
+    pfn_shutdown        shutdown;
+    pfn_getsockname     sockname;
+    pfn_getpeername     peername;
+    pfn_sendto          send_to;
+    pfn_recvfrom        recv_from;
+    pfn_WSAPoll         poll;
+};
+
+inline network_calls& net_calls() {
+    static network_calls c = {};    // constant-initialised: no guard is emitted
+    return c;
+}
+
+// ⚠️ THE LIBRARY'S NAME IS WRITTEN AS WIDE CHARACTERS BY HAND. This package has
+// no C library to take a literal converter from, and `L"ws2_32.dll"' is the
+// language's own; it is spelled out so that no header is needed for it.
+inline bool ensure_network() {
+    network_calls& c = net_calls();
+    if (c.ready != 0) return c.ready > 0;
+
+    static const wchar_t name[] = { L'w', L's', L'2', L'_', L'3', L'2', L'.',
+                                    L'd', L'l', L'l', L'\0' };
+    HANDLE lib = LoadLibraryW(name);
+    if (lib == nullptr) { c.ready = -1; return false; }
+
+    auto at = [lib](const char* n) { return GetProcAddress(lib, n); };
+    auto start = reinterpret_cast<pfn_WSAStartup>(at("WSAStartup"));
+    c.last_error = reinterpret_cast<pfn_WSAGetLastError>(at("WSAGetLastError"));
+    c.socket     = reinterpret_cast<pfn_WSASocketW>(at("WSASocketW"));
+    c.close      = reinterpret_cast<pfn_closesocket>(at("closesocket"));
+    c.bind       = reinterpret_cast<pfn_bind>(at("bind"));
+    c.listen     = reinterpret_cast<pfn_listen>(at("listen"));
+    c.accept     = reinterpret_cast<pfn_accept>(at("accept"));
+    c.connect    = reinterpret_cast<pfn_connect>(at("connect"));
+    c.shutdown   = reinterpret_cast<pfn_shutdown>(at("shutdown"));
+    c.sockname   = reinterpret_cast<pfn_getsockname>(at("getsockname"));
+    c.peername   = reinterpret_cast<pfn_getpeername>(at("getpeername"));
+    c.send_to    = reinterpret_cast<pfn_sendto>(at("sendto"));
+    c.recv_from  = reinterpret_cast<pfn_recvfrom>(at("recvfrom"));
+    c.poll       = reinterpret_cast<pfn_WSAPoll>(at("WSAPoll"));
+
+    // ⚠️ EVERY ONE OF THEM, OR NONE. A table with one null entry is worse than
+    // no table: the operations that resolved would work and the one that did
+    // not would call through zero, which is the failure clause 6.1 exists to
+    // turn into a link error and this arrangement cannot.
+    if (!start || !c.last_error || !c.socket || !c.close || !c.bind ||
+        !c.listen || !c.accept || !c.connect || !c.shutdown || !c.sockname ||
+        !c.peername || !c.send_to || !c.recv_from || !c.poll) {
+        c.ready = -1;
+        return false;
+    }
+
     unsigned char record[1024];   // larger than the documented layout; see win32.h
-    if (WSAStartup(0x0202 /* version 2.2 */, record) == 0) started = 1;
+    if (start(0x0202 /* version 2.2 */, record) != 0) { c.ready = -1; return false; }
+    c.ready = 1;
+    return true;
+}
+
+// The error this system last reported for a socket operation. ⚠️ Reached through
+// the table, so a caller that failed BEFORE the table was built --- which is the
+// only way `ensure_network' returns false --- is told `kal_err_io' rather than
+// calling through a null pointer.
+inline int last_socket_error() {
+    network_calls& c = net_calls();
+    if (c.ready <= 0 || c.last_error == nullptr) return kal_err_io;
+    return translate_wsa(c.last_error());
+}
+
+// The table, or a null pointer when this system's network interface could not
+// be reached at all. ⚠️ Every operation of both interfaces begins here, so a
+// system without `ws2_32.dll' --- which is not a system this package expects to
+// meet --- reports `kal_err_io' rather than calling through zero.
+inline network_calls* net_or_null() {
+    return ensure_network() ? &net_calls() : nullptr;
 }
 
 // ── addresses ───────────────────────────────────────────────────────────────