winipc 0.1.0

data/ext/winipc/winipc.c

@@ -0,0 +1,1246 @@
+/*
+ * winipc — Windows local IPC for Ruby: named pipes, shared memory (file
+ * mappings), and named synchronization objects (mutex / event / semaphore).
+ *
+ * PURE C (no C++), so rb_raise/longjmp is the normal, safe error mechanism —
+ * the same discipline as winloop, and the opposite of the lithos /EHsc hazard.
+ * Every kernel object lives in a TypedData wrapper whose free hook closes it,
+ * so a forgotten #close never leaks a HANDLE. Blocking waits release the GVL
+ * (rb_thread_call_without_gvl) with an unblock function so other Ruby threads
+ * run and Thread#kill / Ctrl-C / Timeout can break them.
+ *
+ * Links kernel32 (pipes / mappings / sync) + advapi32 (security descriptors).
+ */
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <ruby/encoding.h>
+#include <limits.h>
+
+#include <windows.h>
+#include <sddl.h>   /* ConvertStringSecurityDescriptorToSecurityDescriptorW, ConvertSidToStringSidW */
+
+/* ------------------------------------------------------------------ globals */
+
+static VALUE mWinipc;
+static VALUE cPipe, cListener, cConn, cSharedMemory, cMutex, cEvent, cSemaphore;
+static VALUE eError, eOSError, eTimeout, eNotFound, eExists, eAccessDenied,
+             eBrokenPipe, ePipeBusy, eCanceled, eModeError, eRangeError,
+             eClosed, eNotOwner, eAbandoned, eWouldExceedMax;
+
+/* ------------------------------------------------------------ small helpers */
+
+/* UTF-8 Ruby String -> freshly xmalloc'd NUL-terminated UTF-16. Caller xfrees. */
+static WCHAR *
+to_wide(VALUE str)
+{
+    int len, n;
+    WCHAR *w;
+    StringValue(str);
+    len = (int)RSTRING_LEN(str);
+    if (len == 0) {
+        w = (WCHAR *)xmalloc(sizeof(WCHAR));
+        w[0] = 0;
+        return w;
+    }
+    n = MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(str), len, NULL, 0);
+    if (n <= 0) rb_raise(eError, "winipc: invalid UTF-8 in name");
+    w = (WCHAR *)xmalloc(sizeof(WCHAR) * (n + 1));
+    MultiByteToWideChar(CP_UTF8, 0, RSTRING_PTR(str), len, w, n);
+    w[n] = 0;
+    return w;
+}
+
+/* Build + raise a winipc error carrying @code (the Win32 error). The code must
+ * be captured by the caller immediately after the failing syscall. */
+static void
+raise_code(VALUE klass, const char *api, DWORD code)
+{
+    VALUE exc, msg;
+    WCHAR *buf = NULL;
+    char detail[512];
+    DWORD n;
+
+    detail[0] = 0;
+    n = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+                       FORMAT_MESSAGE_IGNORE_INSERTS, NULL, code,
+                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&buf, 0, NULL);
+    if (n && buf) {
+        /* trim trailing CR/LF/period, then copy to a stack buffer */
+        while (n && (buf[n-1] == L'\r' || buf[n-1] == L'\n' || buf[n-1] == L'.')) buf[--n] = 0;
+        WideCharToMultiByte(CP_UTF8, 0, buf, -1, detail, (int)sizeof(detail), NULL, NULL);
+        detail[sizeof(detail) - 1] = 0;
+    }
+    /* Release the OS buffer BEFORE any Ruby allocation, so an OOM longjmp from
+     * rb_sprintf / rb_exc_new_str cannot leak it. */
+    if (buf) LocalFree(buf);
+
+    if (detail[0])
+        msg = rb_sprintf("%s: %s (error %lu)", api, detail, (unsigned long)code);
+    else
+        msg = rb_sprintf("%s failed (error %lu)", api, (unsigned long)code);
+    exc = rb_exc_new_str(klass, msg);
+    rb_iv_set(exc, "@code", ULONG2NUM(code));
+    rb_exc_raise(exc);
+}
+
+/* Pick the right subclass for a Win32 error and raise it (used at call sites
+ * that don't have a more specific mapping). */
+static void
+raise_gle(const char *api, DWORD code)
+{
+    VALUE klass = eOSError;
+    switch (code) {
+        case ERROR_FILE_NOT_FOUND:  klass = eNotFound;     break; /* 2   */
+        case ERROR_ACCESS_DENIED:   klass = eAccessDenied; break; /* 5   */
+        case ERROR_BROKEN_PIPE:                                   /* 109 */
+        case ERROR_NO_DATA:                                       /* 232 */
+        case ERROR_PIPE_NOT_CONNECTED: klass = eBrokenPipe; break;/* 233 */
+        case ERROR_OPERATION_ABORTED: klass = eCanceled;   break; /* 995 */
+        case ERROR_SEM_TIMEOUT:     klass = eTimeout;      break; /* 121 */
+        case ERROR_PIPE_BUSY:       klass = ePipeBusy;     break; /* 231 */
+        default: break;
+    }
+    raise_code(klass, api, code);
+}
+
+/* Length of a Ruby String as a DWORD, guarding the 4 GiB ceiling. */
+static DWORD
+dword_len(VALUE str)
+{
+    long n;
+    StringValue(str);
+    n = RSTRING_LEN(str);
+    if ((unsigned long long)n > 0xFFFFFFFFull)
+        rb_raise(rb_eArgError, "winipc: data too large (> 4 GiB)");
+    return (DWORD)n;
+}
+
+/* ----------------------------------------------------- security descriptors */
+
+/* Build a SECURITY_ATTRIBUTES for the requested access policy. Returns 1 and
+ * fills *sa (+ *psd to LocalFree later) when an explicit SD is used, or 0 when
+ * the caller should pass NULL (default ACL). access:
+ *   :everyone / nil  -> 0 (NULL sa = OS default ACL)
+ *   :owner           -> explicit SD: current user + SYSTEM + Administrators
+ *   a String         -> treated as an SDDL descriptor
+ */
+static int
+build_sa(VALUE access, SECURITY_ATTRIBUTES *sa, PSECURITY_DESCRIPTOR *psd)
+{
+    WCHAR *sddl = NULL;
+    int owned = 0; /* whether sddl was xmalloc'd */
+    PSECURITY_DESCRIPTOR sd = NULL;
+    WCHAR owner_sddl[320]; /* function-scope so it outlives the :owner block */
+
+    *psd = NULL;
+    if (NIL_P(access) || access == ID2SYM(rb_intern("everyone")))
+        return 0;
+
+    if (access == ID2SYM(rb_intern("owner"))) {
+        HANDLE tok = NULL;
+        DWORD cb = 0;
+        TOKEN_USER *tu = NULL;
+        LPWSTR sidstr = NULL;
+
+        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &tok))
+            raise_gle("OpenProcessToken", GetLastError());
+        GetTokenInformation(tok, TokenUser, NULL, 0, &cb);
+        /* plain malloc (not xmalloc) so an OOM doesn't longjmp and leak `tok` */
+        tu = (TOKEN_USER *)malloc(cb ? cb : 1);
+        if (!tu) { CloseHandle(tok); rb_raise(rb_eNoMemError, "winipc: out of memory"); }
+        if (!GetTokenInformation(tok, TokenUser, tu, cb, &cb)) {
+            DWORD e = GetLastError(); CloseHandle(tok); free(tu);
+            raise_gle("GetTokenInformation", e);
+        }
+        if (!ConvertSidToStringSidW(tu->User.Sid, &sidstr)) {
+            DWORD e = GetLastError(); CloseHandle(tok); free(tu);
+            raise_gle("ConvertSidToStringSid", e);
+        }
+        CloseHandle(tok);
+        free(tu);
+        /* Format into the stack buffer and free sidstr immediately, so no OS
+         * allocation is held across a later raise. (A string SID is well under
+         * the buffer size.) */
+        _snwprintf(owner_sddl, 320, L"D:(A;;GA;;;%s)(A;;GA;;;SY)(A;;GA;;;BA)", sidstr);
+        owner_sddl[319] = 0;
+        LocalFree(sidstr);
+        sddl = owner_sddl;
+        owned = 0; /* stack buffer; nothing to xfree */
+    } else {
+        /* explicit SDDL string */
+        sddl = to_wide(access);
+        owned = 1;
+    }
+
+    if (!ConvertStringSecurityDescriptorToSecurityDescriptorW(sddl, SDDL_REVISION_1, &sd, NULL)) {
+        DWORD e = GetLastError();
+        if (owned) xfree(sddl);
+        raise_gle("ConvertStringSecurityDescriptor", e);
+    }
+    if (owned) xfree(sddl);
+
+    sa->nLength = sizeof(*sa);
+    sa->lpSecurityDescriptor = sd;
+    sa->bInheritHandle = FALSE;
+    *psd = sd;
+    return 1;
+}
+
+/* =====================================================================
+ * Named pipe connection — Winipc::Pipe::Conn
+ * ===================================================================== */
+
+typedef struct {
+    HANDLE h;
+    HANDLE read_event;  /* manual-reset event for an in-flight read  */
+    HANDLE write_event; /* manual-reset event for an in-flight write */
+    int is_server;
+    int message_read;   /* PIPE_READMODE_MESSAGE in effect */
+    int closed;
+} conn_t;
+
+static void
+conn_free(void *p)
+{
+    conn_t *c = (conn_t *)p;
+    /* Graceful close: just CloseHandle. The peer can drain any buffered data
+     * and then sees EOF. (DisconnectNamedPipe would discard unread data — e.g.
+     * a reply the server just wrote — so it is deliberately NOT used here.) */
+    if (c->h && c->h != INVALID_HANDLE_VALUE) {
+        CloseHandle(c->h);
+    }
+    if (c->read_event) CloseHandle(c->read_event);
+    if (c->write_event) CloseHandle(c->write_event);
+    xfree(c);
+}
+
+static const rb_data_type_t conn_type = {
+    "Winipc::Pipe::Conn", { 0, conn_free, 0, }, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+conn_alloc(VALUE klass)
+{
+    conn_t *c;
+    VALUE obj = TypedData_Make_Struct(klass, conn_t, &conn_type, c);
+    c->h = INVALID_HANDLE_VALUE;
+    c->read_event = NULL;
+    c->write_event = NULL;
+    c->is_server = 0;
+    c->message_read = 0;
+    c->closed = 0;
+    return obj;
+}
+
+static conn_t *
+conn_get(VALUE self)
+{
+    conn_t *c;
+    TypedData_Get_Struct(self, conn_t, &conn_type, c);
+    return c;
+}
+
+static conn_t *
+conn_live(VALUE self)
+{
+    conn_t *c = conn_get(self);
+    if (c->closed || c->h == INVALID_HANDLE_VALUE)
+        rb_raise(eClosed, "winipc: connection is closed");
+    return c;
+}
+
+/* --- GVL-released wait on an overlapped op, cancelable via CancelIoEx ------ */
+
+typedef struct {
+    HANDLE h;
+    OVERLAPPED *ov;
+    DWORD ms;
+    DWORD wait;
+    DWORD gle;
+} ov_wait_t;
+
+static void *
+ov_wait_fn(void *p)
+{
+    ov_wait_t *w = (ov_wait_t *)p;
+    w->wait = WaitForSingleObject(w->ov->hEvent, w->ms);
+    if (w->wait == WAIT_FAILED) w->gle = GetLastError(); /* capture before GVL */
+    return NULL;
+}
+
+static void
+ov_wait_ubf(void *p)
+{
+    ov_wait_t *w = (ov_wait_t *)p;
+    /* Cancel THIS specific overlapped op. Passing the OVERLAPPED* (not NULL)
+     * cancels it regardless of which thread issued it — required because the
+     * unblock runs on a different thread than the blocked wait. */
+    CancelIoEx(w->h, w->ov);
+}
+
+/* Wait for a pending overlapped op to complete (GVL released, cancelable).
+ * Returns the WaitForSingleObject result; *gle gets GetLastError on WAIT_FAILED. */
+static DWORD
+ov_wait(HANDLE h, OVERLAPPED *ov, DWORD ms, DWORD *gle)
+{
+    ov_wait_t w;
+    w.h = h;
+    w.ov = ov;
+    w.ms = ms;
+    w.wait = WAIT_FAILED;
+    w.gle = 0;
+    rb_thread_call_without_gvl(ov_wait_fn, &w, ov_wait_ubf, &w);
+    if (gle) *gle = w.gle;
+    return w.wait;
+}
+
+/* Cancel a still-pending overlapped op and wait for it to settle, so its
+ * OVERLAPPED and buffer can be safely freed before we raise. */
+static void
+ov_drain(HANDLE h, OVERLAPPED *ov)
+{
+    DWORD n;
+    CancelIoEx(h, ov);
+    GetOverlappedResult(h, ov, &n, TRUE);
+}
+
+/* =====================================================================
+ * Listener — Winipc::Pipe::Listener
+ * ===================================================================== */
+
+typedef struct {
+    WCHAR *name;
+    DWORD open_mode;   /* PIPE_ACCESS_* | FILE_FLAG_OVERLAPPED [| FIRST_PIPE_INSTANCE] */
+    DWORD pipe_mode;   /* PIPE_TYPE_* | PIPE_READMODE_* | PIPE_WAIT [| REJECT_REMOTE] */
+    DWORD max_inst;
+    DWORD in_buf;
+    DWORD out_buf;
+    PSECURITY_DESCRIPTOR psd;  /* may be NULL */
+    HANDLE pending;            /* the next instance awaiting a client (live after listen) */
+    HANDLE event;              /* manual-reset event for the pending instance's connect */
+    int first_done;
+    int closed;
+} listener_t;
+
+static void
+listener_free(void *p)
+{
+    listener_t *l = (listener_t *)p;
+    if (l->pending && l->pending != INVALID_HANDLE_VALUE) {
+        DisconnectNamedPipe(l->pending);
+        CloseHandle(l->pending);
+    }
+    if (l->event) CloseHandle(l->event);
+    if (l->name) xfree(l->name);
+    if (l->psd) LocalFree(l->psd);
+    xfree(l);
+}
+
+static const rb_data_type_t listener_type = {
+    "Winipc::Pipe::Listener", { 0, listener_free, 0, }, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+listener_alloc(VALUE klass)
+{
+    listener_t *l;
+    VALUE obj = TypedData_Make_Struct(klass, listener_t, &listener_type, l);
+    l->name = NULL;
+    l->psd = NULL;
+    l->pending = INVALID_HANDLE_VALUE;
+    l->event = NULL;
+    l->first_done = 0;
+    l->closed = 0;
+    return obj;
+}
+
+static listener_t *
+listener_get(VALUE self)
+{
+    listener_t *l;
+    TypedData_Get_Struct(self, listener_t, &listener_type, l);
+    return l;
+}
+
+/* Create one pipe instance per the listener's config. FILE_FLAG_FIRST_PIPE_INSTANCE
+ * goes on the very first instance only, so a squatter can't pre-own the name. */
+static HANDLE
+listener_make_instance(listener_t *l)
+{
+    DWORD open_mode = l->open_mode | (l->first_done ? 0 : FILE_FLAG_FIRST_PIPE_INSTANCE);
+    SECURITY_ATTRIBUTES sa;
+    LPSECURITY_ATTRIBUTES psa = NULL;
+    HANDLE h;
+    if (l->psd) { sa.nLength = sizeof(sa); sa.lpSecurityDescriptor = l->psd; sa.bInheritHandle = FALSE; psa = &sa; }
+    h = CreateNamedPipeW(l->name, open_mode, l->pipe_mode, l->max_inst,
+                         l->out_buf, l->in_buf, 0, psa);
+    if (h == INVALID_HANDLE_VALUE)
+        raise_gle("CreateNamedPipe", GetLastError());
+    l->first_done = 1;
+    return h;
+}
+
+/* Winipc::Pipe._listen(wname, open_mode, pipe_mode, max_inst, in_buf, out_buf, access) */
+static VALUE
+pipe_listen(VALUE klass, VALUE wname, VALUE open_mode, VALUE pipe_mode,
+            VALUE max_inst, VALUE in_buf, VALUE out_buf, VALUE access)
+{
+    VALUE obj = listener_alloc(cListener);
+    listener_t *l = listener_get(obj);
+    SECURITY_ATTRIBUTES sa;
+    PSECURITY_DESCRIPTOR psd = NULL;
+
+    l->open_mode = NUM2ULONG(open_mode);
+    l->pipe_mode = NUM2ULONG(pipe_mode);
+    l->max_inst  = NUM2ULONG(max_inst);
+    l->in_buf    = NUM2ULONG(in_buf);
+    l->out_buf   = NUM2ULONG(out_buf);
+    l->name      = to_wide(wname); /* already \\.\pipe\... from Ruby */
+    if (build_sa(access, &sa, &psd))
+        l->psd = psd; /* stored; freed in listener_free */
+
+    l->event = CreateEventW(NULL, TRUE, FALSE, NULL);
+    if (!l->event) raise_gle("CreateEvent", GetLastError());
+    /* Create the first listening instance now so the name is live immediately. */
+    l->pending = listener_make_instance(l);
+    return obj;
+}
+
+/* Listener#_accept(timeout_ms) -> Conn, or nil on timeout (-1 ms == INFINITE). */
+static VALUE
+listener_accept(VALUE self, VALUE vms)
+{
+    listener_t *l = listener_get(self);
+    long ms_in = NUM2LONG(vms);
+    DWORD ms = (ms_in < 0) ? INFINITE : (DWORD)ms_in;
+    OVERLAPPED ov;
+    HANDLE cur;
+    VALUE connobj;
+    conn_t *c;
+    DWORD gle, wgle = 0;
+    int connected = 0;
+
+    if (l->closed) rb_raise(eClosed, "winipc: listener is closed");
+    if (l->pending == INVALID_HANDLE_VALUE)
+        l->pending = listener_make_instance(l); /* recover if a prior accept failed mid-rotate */
+
+    memset(&ov, 0, sizeof(ov));
+    ov.hEvent = l->event;
+    ResetEvent(l->event);
+
+    if (ConnectNamedPipe(l->pending, &ov)) {
+        connected = 1; /* completed synchronously (rare) */
+    } else {
+        gle = GetLastError();
+        if (gle == ERROR_PIPE_CONNECTED) {
+            connected = 1; /* client connected in the create/connect gap — success */
+        } else if (gle == ERROR_IO_PENDING) {
+            DWORD w = ov_wait(l->pending, &ov, ms, &wgle);
+            DWORD n;
+            if (w == WAIT_TIMEOUT) {
+                CancelIoEx(l->pending, &ov);
+                /* If a client connected during the cancel race, keep it rather
+                 * than orphaning it; otherwise report the timeout. */
+                if (GetOverlappedResult(l->pending, &ov, &n, TRUE))
+                    connected = 1;
+                else
+                    return Qnil;
+            } else if (w != WAIT_OBJECT_0) {
+                ov_drain(l->pending, &ov);
+                raise_gle("WaitForSingleObject", wgle);
+            } else if (GetOverlappedResult(l->pending, &ov, &n, FALSE)) {
+                connected = 1;
+            } else {
+                gle = GetLastError();
+                if (gle == ERROR_OPERATION_ABORTED) return Qnil; /* interrupted */
+                raise_gle("ConnectNamedPipe", gle);
+            }
+        } else {
+            raise_gle("ConnectNamedPipe", gle);
+        }
+    }
+
+    if (!connected) return Qnil;
+
+    /* Move the connected instance into a Conn (so its free hook owns it), then
+     * pre-create the next listening instance so the name stays live for the
+     * next client (no ERROR_FILE_NOT_FOUND gap between accepts). */
+    cur = l->pending;
+    connobj = conn_alloc(cConn);
+    c = conn_get(connobj);
+    c->h = cur;
+    c->is_server = 1;
+    c->message_read = (l->pipe_mode & PIPE_READMODE_MESSAGE) ? 1 : 0;
+    l->pending = INVALID_HANDLE_VALUE; /* ownership moved to the Conn */
+    c->read_event = CreateEventW(NULL, TRUE, FALSE, NULL);
+    c->write_event = CreateEventW(NULL, TRUE, FALSE, NULL);
+    if (!c->read_event || !c->write_event) raise_gle("CreateEvent", GetLastError());
+
+    l->pending = listener_make_instance(l);
+    return connobj;
+}
+
+static VALUE
+listener_close(VALUE self)
+{
+    listener_t *l = listener_get(self);
+    if (l->pending && l->pending != INVALID_HANDLE_VALUE) {
+        DisconnectNamedPipe(l->pending);
+        CloseHandle(l->pending);
+        l->pending = INVALID_HANDLE_VALUE;
+    }
+    if (l->event) { CloseHandle(l->event); l->event = NULL; }
+    l->closed = 1;
+    return Qnil;
+}
+
+static VALUE
+listener_closed_p(VALUE self)
+{
+    return listener_get(self)->closed ? Qtrue : Qfalse;
+}
+
+/* =====================================================================
+ * Client connect — Winipc::Pipe._connect
+ * ===================================================================== */
+
+/* WaitNamedPipeW with the GVL released. */
+typedef struct { const WCHAR *name; DWORD ms; BOOL ok; DWORD gle; } wnp_t;
+static void *wnp_fn(void *p) {
+    wnp_t *w = (wnp_t *)p;
+    w->ok = WaitNamedPipeW(w->name, w->ms);
+    w->gle = w->ok ? 0 : GetLastError();
+    return NULL;
+}
+
+/* Sleep with the GVL released (short slices, used while polling for a server
+ * instance to appear). */
+static void *sleep_fn(void *p) { Sleep(*(DWORD *)p); return NULL; }
+static void sleep_gvl(DWORD ms) {
+    rb_thread_call_without_gvl(sleep_fn, &ms, RUBY_UBF_IO, NULL);
+}
+
+/* Winipc::Pipe._connect(wname, access_rights, want_message, timeout_ms) -> Conn */
+static VALUE
+pipe_connect(VALUE klass, VALUE wname, VALUE access_rights, VALUE want_message, VALUE vms)
+{
+    DWORD access = NUM2ULONG(access_rights);
+    long ms_in = NUM2LONG(vms);
+    int want_msg = RTEST(want_message);
+    HANDLE h = INVALID_HANDLE_VALUE;
+    VALUE connobj;
+    conn_t *c;
+    DWORD gle;
+    ULONGLONG deadline = (ms_in > 0) ? GetTickCount64() + (ULONGLONG)ms_in : 0;
+
+    /* The wide name is rebuilt each iteration and freed before any raise /
+     * interrupt check, so an interrupt (Thread#kill/Timeout) raised mid-loop
+     * never leaks it. Each blocking wait is sliced so interrupts are serviced
+     * promptly rather than only at the deadline. */
+    for (;;) {
+        WCHAR *name = to_wide(wname);
+        DWORD remaining, slice;
+        h = CreateFileW(name, access, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+        if (h != INVALID_HANDLE_VALUE) { xfree(name); break; }
+        gle = GetLastError();
+
+        if (!((gle == ERROR_PIPE_BUSY || gle == ERROR_FILE_NOT_FOUND) && ms_in != 0)) {
+            xfree(name);
+            raise_gle("CreateFile(pipe)", gle);
+        }
+        /* server busy (all instances in use) or not-yet-present — wait/poll */
+        if (ms_in < 0) {
+            remaining = INFINITE;
+        } else {
+            ULONGLONG now = GetTickCount64();
+            if (now >= deadline) { xfree(name); raise_gle("Connect(pipe)", gle); }
+            remaining = (DWORD)(deadline - now);
+        }
+        slice = (remaining == INFINITE || remaining > 100) ? 100 : remaining;
+        if (gle == ERROR_PIPE_BUSY) {
+            wnp_t w;
+            w.name = name; w.ms = slice; w.ok = FALSE; w.gle = 0;
+            rb_thread_call_without_gvl(wnp_fn, &w, RUBY_UBF_IO, NULL);
+        } else {
+            sleep_gvl(slice);
+        }
+        xfree(name);              /* freed before the interrupt check below */
+        rb_thread_check_ints();   /* deliver Thread#kill / Timeout promptly */
+    }
+
+    connobj = conn_alloc(cConn);
+    c = conn_get(connobj);
+    c->h = h;
+    c->is_server = 0;
+    c->read_event = CreateEventW(NULL, TRUE, FALSE, NULL);
+    c->write_event = CreateEventW(NULL, TRUE, FALSE, NULL);
+    if (!c->read_event || !c->write_event) raise_gle("CreateEvent", GetLastError());
+
+    if (want_msg) {
+        DWORD mode = PIPE_READMODE_MESSAGE;
+        if (!SetNamedPipeHandleState(c->h, &mode, NULL, NULL))
+            raise_gle("SetNamedPipeHandleState", GetLastError());
+        c->message_read = 1;
+    }
+    return connobj;
+}
+
+/* =====================================================================
+ * Conn I/O
+ * ===================================================================== */
+
+/* One overlapped read into a buffer of cap bytes. Returns:
+ *   >=0  bytes read (0 means peer wrote 0 bytes)
+ *   -1   clean EOF (peer closed)            -> Ruby nil
+ *   -2   more data available (message mode) -> caller loops
+ * Raises on real errors. *abort_canceled set if cancelled. */
+#define READ_EOF  (-1)
+#define READ_MORE (-2)
+
+static long
+conn_read_once(conn_t *c, char *buf, DWORD cap)
+{
+    OVERLAPPED ov;
+    DWORD n = 0, gle, wgle = 0;
+    BOOL ok;
+
+    memset(&ov, 0, sizeof(ov));
+    ov.hEvent = c->read_event;
+    ResetEvent(c->read_event);
+
+    ok = ReadFile(c->h, buf, cap, &n, &ov);
+    if (!ok) {
+        gle = GetLastError();
+        if (gle == ERROR_IO_PENDING) {
+            DWORD w = ov_wait(c->h, &ov, INFINITE, &wgle);
+            if (w != WAIT_OBJECT_0) { ov_drain(c->h, &ov); raise_gle("WaitForSingleObject", wgle); }
+            ok = GetOverlappedResult(c->h, &ov, &n, FALSE);
+            if (!ok) {
+                gle = GetLastError();
+                if (gle == ERROR_BROKEN_PIPE || gle == ERROR_PIPE_NOT_CONNECTED) return READ_EOF;
+                raise_gle("ReadFile", gle); /* ERROR_OPERATION_ABORTED -> Canceled */
+            }
+            return (long)n;
+        }
+        if (gle == ERROR_BROKEN_PIPE || gle == ERROR_PIPE_NOT_CONNECTED) return READ_EOF;
+        raise_gle("ReadFile", gle);
+    }
+    return (long)n;
+}
+
+/* Conn#_read(maxlen) -> String or nil (EOF). Byte semantics: returns up to
+ * maxlen bytes as they arrive. */
+static VALUE
+conn_read(VALUE self, VALUE vmax)
+{
+    conn_t *c = conn_live(self);
+    long max = NUM2LONG(vmax);
+    VALUE out;
+    long r;
+
+    if (max <= 0) rb_raise(rb_eArgError, "winipc: read length must be > 0");
+    if (c->message_read)
+        rb_raise(eModeError, "winipc: use #read_message on a message-mode pipe");
+    out = rb_str_new(NULL, max);
+    r = conn_read_once(c, RSTRING_PTR(out), (DWORD)max);
+    if (r == READ_EOF) return Qnil;
+    rb_str_set_len(out, r);
+    rb_enc_associate(out, rb_ascii8bit_encoding());
+    return out;
+}
+
+/* Conn#_read_message(maxlen) -> String or nil. Reassembles a whole message,
+ * growing past ERROR_MORE_DATA. */
+static VALUE
+conn_read_message(VALUE self, VALUE vmax)
+{
+    conn_t *c = conn_live(self);
+    long max = NUM2LONG(vmax);
+    OVERLAPPED ov;
+    DWORD n = 0, gle, off = 0, cap;
+    VALUE out;
+    BOOL ok;
+
+    if (max <= 0) rb_raise(rb_eArgError, "winipc: read length must be > 0");
+    cap = (DWORD)max;
+    out = rb_str_new(NULL, cap);
+
+    for (;;) {
+        DWORD wgle = 0;
+        memset(&ov, 0, sizeof(ov));
+        ov.hEvent = c->read_event;
+        ResetEvent(c->read_event);
+        ok = ReadFile(c->h, RSTRING_PTR(out) + off, cap - off, &n, &ov);
+        if (!ok) {
+            gle = GetLastError();
+            if (gle == ERROR_IO_PENDING) {
+                DWORD w = ov_wait(c->h, &ov, INFINITE, &wgle);
+                if (w != WAIT_OBJECT_0) { ov_drain(c->h, &ov); raise_gle("WaitForSingleObject", wgle); }
+                ok = GetOverlappedResult(c->h, &ov, &n, FALSE);
+                if (!ok) gle = GetLastError();
+            }
+            if (!ok) {
+                if (gle == ERROR_MORE_DATA) {
+                    off += n;
+                    if (cap > 0x7FFFFFFFu / 2u) rb_raise(rb_eArgError, "winipc: message too large");
+                    cap *= 2;
+                    rb_str_resize(out, cap);
+                    continue;
+                }
+                if (gle == ERROR_BROKEN_PIPE || gle == ERROR_PIPE_NOT_CONNECTED) {
+                    if (off == 0) return Qnil; /* clean EOF before any bytes */
+                    raise_gle("ReadFile", gle);
+                }
+                raise_gle("ReadFile", gle);
+            }
+        }
+        off += n;
+        break;
+    }
+    rb_str_set_len(out, off);
+    rb_enc_associate(out, rb_ascii8bit_encoding());
+    return out;
+}
+
+/* Conn#_write(bytes) -> Integer bytes written. */
+static VALUE
+conn_write(VALUE self, VALUE data)
+{
+    conn_t *c = conn_live(self);
+    OVERLAPPED ov;
+    DWORD len, n = 0, gle, wgle = 0;
+    const char *p;
+    BOOL ok;
+
+    len = dword_len(data);
+    p = RSTRING_PTR(data);
+    memset(&ov, 0, sizeof(ov));
+    ov.hEvent = c->write_event;
+    ResetEvent(c->write_event);
+
+    ok = WriteFile(c->h, p, len, &n, &ov);
+    if (!ok) {
+        gle = GetLastError();
+        if (gle == ERROR_IO_PENDING) {
+            DWORD w = ov_wait(c->h, &ov, INFINITE, &wgle);
+            if (w != WAIT_OBJECT_0) { ov_drain(c->h, &ov); raise_gle("WaitForSingleObject", wgle); }
+            ok = GetOverlappedResult(c->h, &ov, &n, FALSE);
+            if (!ok) gle = GetLastError();
+        }
+        if (!ok) raise_gle("WriteFile", gle);
+    }
+    return ULONG2NUM(n);
+}
+
+static VALUE
+conn_flush(VALUE self)
+{
+    conn_t *c = conn_live(self);
+    if (!FlushFileBuffers(c->h)) raise_gle("FlushFileBuffers", GetLastError());
+    return self;
+}
+
+static VALUE
+conn_close(VALUE self)
+{
+    conn_t *c = conn_get(self);
+    if (!c->closed && c->h != INVALID_HANDLE_VALUE) {
+        CloseHandle(c->h); /* graceful: peer drains buffered data, then EOF */
+        c->h = INVALID_HANDLE_VALUE;
+    }
+    if (c->read_event) { CloseHandle(c->read_event); c->read_event = NULL; }
+    if (c->write_event) { CloseHandle(c->write_event); c->write_event = NULL; }
+    c->closed = 1;
+    return Qnil;
+}
+
+static VALUE conn_closed_p(VALUE self) { return conn_get(self)->closed ? Qtrue : Qfalse; }
+static VALUE conn_server_p(VALUE self) { return conn_get(self)->is_server ? Qtrue : Qfalse; }
+static VALUE conn_message_p(VALUE self) { return conn_get(self)->message_read ? Qtrue : Qfalse; }
+
+/* =====================================================================
+ * Shared memory — Winipc::SharedMemory
+ * ===================================================================== */
+
+typedef struct {
+    HANDLE map;
+    void *view;
+    unsigned long long size;
+    int writable;
+    int closed;
+} shm_t;
+
+static void
+shm_free(void *p)
+{
+    shm_t *s = (shm_t *)p;
+    if (s->view) UnmapViewOfFile(s->view);
+    if (s->map) CloseHandle(s->map);
+    xfree(s);
+}
+
+static const rb_data_type_t shm_type = {
+    "Winipc::SharedMemory", { 0, shm_free, 0, }, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+shm_alloc(VALUE klass)
+{
+    shm_t *s;
+    VALUE obj = TypedData_Make_Struct(klass, shm_t, &shm_type, s);
+    s->map = NULL; s->view = NULL; s->size = 0; s->writable = 1; s->closed = 0;
+    return obj;
+}
+
+static shm_t *
+shm_get(VALUE self)
+{
+    shm_t *s;
+    TypedData_Get_Struct(self, shm_t, &shm_type, s);
+    return s;
+}
+
+static shm_t *
+shm_live(VALUE self)
+{
+    shm_t *s = shm_get(self);
+    if (s->closed || !s->view) rb_raise(eClosed, "winipc: shared memory is closed");
+    return s;
+}
+
+/* SharedMemory._create(wname, size, readwrite, access) -> SharedMemory */
+static VALUE
+shm_create(VALUE klass, VALUE wname, VALUE vsize, VALUE rw, VALUE access)
+{
+    VALUE obj = shm_alloc(cSharedMemory);
+    shm_t *s = shm_get(obj);
+    unsigned long long size = NUM2ULL(vsize);
+    int writable = RTEST(rw);
+    SECURITY_ATTRIBUTES sa;
+    PSECURITY_DESCRIPTOR psd = NULL;
+    DWORD prot = writable ? PAGE_READWRITE : PAGE_READONLY;
+    DWORD hi = (DWORD)(size >> 32), lo = (DWORD)(size & 0xFFFFFFFFull);
+    DWORD gle;
+    int use_sa;
+    WCHAR *name;
+
+    if (size == 0) rb_raise(rb_eArgError, "winipc: size must be > 0");
+    use_sa = build_sa(access, &sa, &psd); /* may raise; do before allocating name */
+    name = to_wide(wname);
+
+    s->map = CreateFileMappingW(INVALID_HANDLE_VALUE, use_sa ? &sa : NULL, prot, hi, lo, name);
+    gle = GetLastError();
+    xfree(name);
+    if (psd) LocalFree(psd);
+    if (!s->map) raise_gle("CreateFileMapping", gle);
+    if (gle == ERROR_ALREADY_EXISTS) {
+        /* a mapping of that name already exists with its OWN size — refuse */
+        CloseHandle(s->map); s->map = NULL;
+        raise_code(eExists, "CreateFileMapping", ERROR_ALREADY_EXISTS);
+    }
+
+    s->view = MapViewOfFile(s->map, writable ? FILE_MAP_WRITE : FILE_MAP_READ, 0, 0, 0);
+    if (!s->view) raise_gle("MapViewOfFile", GetLastError());
+    s->size = size;
+    s->writable = writable;
+    return obj;
+}
+
+/* SharedMemory._open(wname, readwrite) -> SharedMemory */
+static VALUE
+shm_open(VALUE klass, VALUE wname, VALUE rw)
+{
+    VALUE obj = shm_alloc(cSharedMemory);
+    shm_t *s = shm_get(obj);
+    int writable = RTEST(rw);
+    WCHAR *name = to_wide(wname);
+    DWORD acc = writable ? FILE_MAP_WRITE : FILE_MAP_READ;
+    MEMORY_BASIC_INFORMATION mbi;
+    DWORD gle;
+
+    s->map = OpenFileMappingW(acc, FALSE, name);
+    gle = GetLastError();
+    xfree(name);
+    if (!s->map) raise_gle("OpenFileMapping", gle);
+
+    s->view = MapViewOfFile(s->map, acc, 0, 0, 0);
+    if (!s->view) raise_gle("MapViewOfFile", GetLastError());
+    /* Discover the mapped region size (the opener didn't specify it). */
+    if (VirtualQuery(s->view, &mbi, sizeof(mbi)) == 0)
+        raise_gle("VirtualQuery", GetLastError());
+    s->size = (unsigned long long)mbi.RegionSize;
+    s->writable = writable;
+    return obj;
+}
+
+static void
+shm_bounds(shm_t *s, unsigned long long off, unsigned long long len)
+{
+    if (off > s->size || len > s->size || off + len > s->size)
+        rb_raise(eRangeError, "winipc: [%llu,%llu) out of bounds (size %llu)",
+                 off, off + len, s->size);
+}
+
+static VALUE
+shm_read(VALUE self, VALUE voff, VALUE vlen)
+{
+    shm_t *s = shm_live(self);
+    unsigned long long off = NUM2ULL(voff), len = NUM2ULL(vlen);
+    VALUE out;
+    shm_bounds(s, off, len);
+    if (len > (unsigned long long)LONG_MAX)
+        rb_raise(rb_eArgError, "winipc: read length too large");
+    out = rb_str_new((const char *)s->view + off, (long)len);
+    rb_enc_associate(out, rb_ascii8bit_encoding());
+    return out;
+}
+
+static VALUE
+shm_write(VALUE self, VALUE voff, VALUE data)
+{
+    shm_t *s = shm_live(self);
+    unsigned long long off = NUM2ULL(voff);
+    DWORD len;
+    if (!s->writable) rb_raise(eError, "winipc: shared memory is read-only");
+    len = dword_len(data);
+    shm_bounds(s, off, (unsigned long long)len);
+    memcpy((char *)s->view + off, RSTRING_PTR(data), len);
+    return ULONG2NUM(len);
+}
+
+static VALUE
+shm_flush(VALUE self, VALUE voff, VALUE vlen)
+{
+    shm_t *s = shm_live(self);
+    unsigned long long off = NUM2ULL(voff), len = NIL_P(vlen) ? 0 : NUM2ULL(vlen);
+    if (off > s->size) rb_raise(eRangeError, "winipc: flush offset out of bounds");
+    if (len) shm_bounds(s, off, len);
+    if (off >= s->size) return self; /* nothing past the end to flush (no-op) */
+    if (!FlushViewOfFile((char *)s->view + off, (SIZE_T)len))
+        raise_gle("FlushViewOfFile", GetLastError());
+    return self;
+}
+
+static VALUE shm_size(VALUE self) { return ULL2NUM(shm_get(self)->size); }
+
+static VALUE
+shm_close(VALUE self)
+{
+    shm_t *s = shm_get(self);
+    if (s->view) { UnmapViewOfFile(s->view); s->view = NULL; }
+    if (s->map) { CloseHandle(s->map); s->map = NULL; }
+    s->closed = 1;
+    return Qnil;
+}
+
+static VALUE shm_closed_p(VALUE self) { return shm_get(self)->closed ? Qtrue : Qfalse; }
+
+/* =====================================================================
+ * Named synchronization objects — Mutex / Event / Semaphore
+ * ===================================================================== */
+
+enum { K_MUTEX, K_EVENT, K_SEM };
+
+typedef struct {
+    HANDLE h;
+    int kind;
+    int created;   /* false if it already existed */
+    int abandoned; /* last wait returned WAIT_ABANDONED (mutex) */
+    int closed;
+} sync_t;
+
+static void
+sync_free(void *p)
+{
+    sync_t *s = (sync_t *)p;
+    if (s->h) CloseHandle(s->h);
+    xfree(s);
+}
+
+static const rb_data_type_t sync_type = {
+    "Winipc::SyncObject", { 0, sync_free, 0, }, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+sync_alloc(VALUE klass)
+{
+    sync_t *s;
+    VALUE obj = TypedData_Make_Struct(klass, sync_t, &sync_type, s);
+    s->h = NULL; s->kind = -1; s->created = 0; s->abandoned = 0; s->closed = 0;
+    return obj;
+}
+
+static sync_t *
+sync_get(VALUE self)
+{
+    sync_t *s;
+    TypedData_Get_Struct(self, sync_t, &sync_type, s);
+    return s;
+}
+
+static sync_t *
+sync_live(VALUE self)
+{
+    sync_t *s = sync_get(self);
+    if (s->closed || !s->h) rb_raise(eClosed, "winipc: object is closed");
+    return s;
+}
+
+/* GVL-released, interruptible wait via bounded slices. Each slice releases the
+ * GVL for at most SYNC_SLICE_MS, then re-acquires it to service interrupts
+ * (Thread#kill / Ctrl-C / Timeout) before continuing. No shared wake object, so
+ * concurrent waiters on the same sync object don't interfere. Returns
+ * WAIT_OBJECT_0 / WAIT_TIMEOUT / WAIT_ABANDONED_0; raises on WAIT_FAILED. */
+#define SYNC_SLICE_MS 100
+typedef struct { HANDLE h; DWORD ms; DWORD result; DWORD gle; } sw_t;
+static void *sw_fn(void *p) {
+    sw_t *w = (sw_t *)p;
+    w->result = WaitForSingleObject(w->h, w->ms);
+    if (w->result == WAIT_FAILED) w->gle = GetLastError(); /* capture before GVL */
+    return NULL;
+}
+
+static DWORD
+sync_wait(sync_t *s, DWORD total_ms)
+{
+    ULONGLONG start = GetTickCount64();
+    for (;;) {
+        sw_t w;
+        DWORD slice;
+        /* A 0-length slice still performs ONE non-blocking probe, so
+         * timeout==0 (try_lock / try_acquire) actually tests the object. */
+        if (total_ms == INFINITE) {
+            slice = SYNC_SLICE_MS;
+        } else {
+            ULONGLONG elapsed = GetTickCount64() - start;
+            DWORD remaining = (elapsed >= total_ms) ? 0 : (DWORD)(total_ms - elapsed);
+            slice = (remaining > SYNC_SLICE_MS) ? SYNC_SLICE_MS : remaining;
+        }
+        w.h = s->h; w.ms = slice; w.result = WAIT_FAILED; w.gle = 0;
+        rb_thread_call_without_gvl(sw_fn, &w, NULL, NULL);
+        if (w.result == WAIT_OBJECT_0)    return WAIT_OBJECT_0;    /* acquired */
+        if (w.result == WAIT_ABANDONED_0) return WAIT_ABANDONED_0; /* mutex abandoned */
+        if (w.result == WAIT_FAILED)      raise_gle("WaitForSingleObject", w.gle);
+        /* WAIT_TIMEOUT for this slice: stop if the overall deadline passed,
+         * else service interrupts and keep waiting. */
+        if (total_ms != INFINITE) {
+            ULONGLONG elapsed = GetTickCount64() - start;
+            if (elapsed >= total_ms) return WAIT_TIMEOUT;
+        }
+        rb_thread_check_ints(); /* may raise (Thread#kill / Timeout) */
+    }
+}
+
+/* sync_create(kind, wname, a, b, access) — a/b meaning depends on kind:
+ *   mutex:     (unused, unused)
+ *   event:     (manual_reset, initial_state)
+ *   semaphore: (initial_count, maximum_count)
+ */
+static VALUE
+sync_create(VALUE klass, VALUE vkind, VALUE wname, VALUE a, VALUE b, VALUE access)
+{
+    VALUE obj = sync_alloc(klass);
+    sync_t *s = sync_get(obj);
+    int kind = NUM2INT(vkind);
+    SECURITY_ATTRIBUTES sa;
+    PSECURITY_DESCRIPTOR psd = NULL;
+    int use_sa = build_sa(access, &sa, &psd); /* may raise; do before allocating name */
+    LPSECURITY_ATTRIBUTES psa = use_sa ? &sa : NULL;
+    WCHAR *name = to_wide(wname);
+    DWORD gle;
+
+    s->kind = kind;
+    if (kind == K_MUTEX) {
+        s->h = CreateMutexW(psa, FALSE, name);
+    } else if (kind == K_EVENT) {
+        s->h = CreateEventW(psa, RTEST(a), RTEST(b), name);
+    } else {
+        s->h = CreateSemaphoreW(psa, NUM2LONG(a), NUM2LONG(b), name);
+    }
+    gle = GetLastError();
+    xfree(name);
+    if (psd) LocalFree(psd);
+    if (!s->h) raise_gle("Create(sync)", gle);
+    s->created = (gle == ERROR_ALREADY_EXISTS) ? 0 : 1;
+    return obj;
+}
+
+/* sync_open(kind, wname) */
+static VALUE
+sync_open(VALUE klass, VALUE vkind, VALUE wname)
+{
+    VALUE obj = sync_alloc(klass);
+    sync_t *s = sync_get(obj);
+    int kind = NUM2INT(vkind);
+    WCHAR *name = to_wide(wname);
+    DWORD gle;
+
+    s->kind = kind;
+    if (kind == K_MUTEX) {
+        s->h = OpenMutexW(SYNCHRONIZE, FALSE, name);
+    } else if (kind == K_EVENT) {
+        s->h = OpenEventW(EVENT_MODIFY_STATE | SYNCHRONIZE, FALSE, name);
+    } else {
+        s->h = OpenSemaphoreW(SEMAPHORE_MODIFY_STATE | SYNCHRONIZE, FALSE, name);
+    }
+    gle = GetLastError();
+    xfree(name);
+    if (!s->h) raise_gle("Open(sync)", gle);
+    s->created = 0;
+    return obj;
+}
+
+/* #_wait(ms) -> :ok / :timeout / :abandoned   (-1 ms = INFINITE) */
+static VALUE
+sync_do_wait(VALUE self, VALUE vms)
+{
+    sync_t *s = sync_live(self);
+    long ms_in = NUM2LONG(vms);
+    DWORD r = sync_wait(s, (ms_in < 0) ? INFINITE : (DWORD)ms_in);
+    if (r == WAIT_OBJECT_0)    return ID2SYM(rb_intern("ok"));
+    if (r == WAIT_TIMEOUT)     return ID2SYM(rb_intern("timeout"));
+    if (r == WAIT_ABANDONED_0) { s->abandoned = 1; return ID2SYM(rb_intern("abandoned")); }
+    return ID2SYM(rb_intern("timeout"));
+}
+
+static VALUE
+mutex_unlock(VALUE self)
+{
+    sync_t *s = sync_live(self);
+    if (!ReleaseMutex(s->h)) {
+        DWORD e = GetLastError();
+        if (e == ERROR_NOT_OWNER) raise_code(eNotOwner, "ReleaseMutex", e);
+        raise_gle("ReleaseMutex", e);
+    }
+    return self;
+}
+
+static VALUE
+event_signal(VALUE self)
+{
+    sync_t *s = sync_live(self);
+    if (!SetEvent(s->h)) raise_gle("SetEvent", GetLastError());
+    return self;
+}
+
+static VALUE
+event_reset(VALUE self)
+{
+    sync_t *s = sync_live(self);
+    if (!ResetEvent(s->h)) raise_gle("ResetEvent", GetLastError());
+    return self;
+}
+
+static VALUE
+sem_release(VALUE self, VALUE vcount)
+{
+    sync_t *s = sync_live(self);
+    LONG count = NUM2LONG(vcount), prev = 0;
+    if (!ReleaseSemaphore(s->h, count, &prev)) {
+        DWORD e = GetLastError();
+        if (e == ERROR_TOO_MANY_POSTS) raise_code(eWouldExceedMax, "ReleaseSemaphore", e);
+        raise_gle("ReleaseSemaphore", e);
+    }
+    return LONG2NUM(prev);
+}
+
+static VALUE sync_created_p(VALUE self)   { return sync_get(self)->created ? Qtrue : Qfalse; }
+static VALUE sync_abandoned_p(VALUE self) { return sync_get(self)->abandoned ? Qtrue : Qfalse; }
+
+static VALUE
+sync_close(VALUE self)
+{
+    sync_t *s = sync_get(self);
+    if (s->h) { CloseHandle(s->h); s->h = NULL; }
+    s->closed = 1;
+    return Qnil;
+}
+
+static VALUE sync_closed_p(VALUE self) { return sync_get(self)->closed ? Qtrue : Qfalse; }
+
+/* ----------------------------------------------------------------- Init --- */
+
+void
+Init_winipc(void)
+{
+    mWinipc = rb_define_module("Winipc");
+
+    eError         = rb_define_class_under(mWinipc, "Error", rb_eStandardError);
+    eOSError       = rb_define_class_under(mWinipc, "OSError", eError);
+    eTimeout       = rb_define_class_under(mWinipc, "TimeoutError", eOSError);
+    eNotFound      = rb_define_class_under(mWinipc, "NotFound", eOSError);
+    eExists        = rb_define_class_under(mWinipc, "Exists", eOSError);
+    eAccessDenied  = rb_define_class_under(mWinipc, "AccessDenied", eOSError);
+    eBrokenPipe    = rb_define_class_under(mWinipc, "BrokenPipe", eOSError);
+    ePipeBusy      = rb_define_class_under(mWinipc, "PipeBusy", eOSError);
+    eCanceled      = rb_define_class_under(mWinipc, "Canceled", eOSError);
+    eModeError     = rb_define_class_under(mWinipc, "ModeError", eError);
+    eRangeError    = rb_define_class_under(mWinipc, "RangeError", eError);
+    eClosed        = rb_define_class_under(mWinipc, "Closed", eError);
+    eNotOwner      = rb_define_class_under(mWinipc, "NotOwner", eOSError);
+    eAbandoned     = rb_define_class_under(mWinipc, "Abandoned", eError);
+    eWouldExceedMax = rb_define_class_under(mWinipc, "WouldExceedMax", eOSError);
+
+    /* Pipe (class methods _listen / _connect; defined in Ruby wrappers too) */
+    cPipe = rb_define_class_under(mWinipc, "Pipe", rb_cObject);
+    rb_define_singleton_method(cPipe, "_listen", pipe_listen, 7);
+    rb_define_singleton_method(cPipe, "_connect", pipe_connect, 4);
+
+    cListener = rb_define_class_under(cPipe, "Listener", rb_cObject);
+    rb_define_alloc_func(cListener, listener_alloc);
+    rb_define_method(cListener, "_accept", listener_accept, 1);
+    rb_define_method(cListener, "close", listener_close, 0);
+    rb_define_method(cListener, "closed?", listener_closed_p, 0);
+
+    cConn = rb_define_class_under(cPipe, "Conn", rb_cObject);
+    rb_define_alloc_func(cConn, conn_alloc);
+    rb_define_method(cConn, "_read", conn_read, 1);
+    rb_define_method(cConn, "_read_message", conn_read_message, 1);
+    rb_define_method(cConn, "_write", conn_write, 1);
+    rb_define_method(cConn, "flush", conn_flush, 0);
+    rb_define_method(cConn, "close", conn_close, 0);
+    rb_define_method(cConn, "closed?", conn_closed_p, 0);
+    rb_define_method(cConn, "server?", conn_server_p, 0);
+    rb_define_method(cConn, "message?", conn_message_p, 0);
+
+    /* SharedMemory */
+    cSharedMemory = rb_define_class_under(mWinipc, "SharedMemory", rb_cObject);
+    rb_define_alloc_func(cSharedMemory, shm_alloc);
+    rb_define_singleton_method(cSharedMemory, "_create", shm_create, 4);
+    rb_define_singleton_method(cSharedMemory, "_open", shm_open, 2);
+    rb_define_method(cSharedMemory, "read", shm_read, 2);
+    rb_define_method(cSharedMemory, "write", shm_write, 2);
+    rb_define_method(cSharedMemory, "_flush", shm_flush, 2);
+    rb_define_method(cSharedMemory, "size", shm_size, 0);
+    rb_define_method(cSharedMemory, "close", shm_close, 0);
+    rb_define_method(cSharedMemory, "closed?", shm_closed_p, 0);
+
+    /* Sync objects share the C constructors; subclasses pass their kind. */
+    rb_define_const(mWinipc, "K_MUTEX", INT2FIX(K_MUTEX));
+    rb_define_const(mWinipc, "K_EVENT", INT2FIX(K_EVENT));
+    rb_define_const(mWinipc, "K_SEM", INT2FIX(K_SEM));
+
+    cMutex = rb_define_class_under(mWinipc, "Mutex", rb_cObject);
+    cEvent = rb_define_class_under(mWinipc, "Event", rb_cObject);
+    cSemaphore = rb_define_class_under(mWinipc, "Semaphore", rb_cObject);
+
+    {
+        VALUE klasses[3]; int i;
+        klasses[0] = cMutex; klasses[1] = cEvent; klasses[2] = cSemaphore;
+        for (i = 0; i < 3; i++) {
+            rb_define_alloc_func(klasses[i], sync_alloc);
+            rb_define_singleton_method(klasses[i], "_create", sync_create, 5);
+            rb_define_singleton_method(klasses[i], "_open", sync_open, 2);
+            rb_define_method(klasses[i], "_wait", sync_do_wait, 1);
+            rb_define_method(klasses[i], "created?", sync_created_p, 0);
+            rb_define_method(klasses[i], "close", sync_close, 0);
+            rb_define_method(klasses[i], "closed?", sync_closed_p, 0);
+        }
+    }
+    rb_define_method(cMutex, "_unlock", mutex_unlock, 0);
+    rb_define_method(cMutex, "abandoned?", sync_abandoned_p, 0);
+    rb_define_method(cEvent, "signal", event_signal, 0);
+    rb_define_method(cEvent, "reset", event_reset, 0);
+    rb_define_method(cSemaphore, "_release", sem_release, 1);
+}