Object and construction

• TcpAcceptor is one object with an atomic Nat8 state word, one listening socket, one pending-accept socket, one address buffer, one dispatcher.Context, and one stored callback.
• INIT sets the state word to 0n8. Default construction therefore creates an unstarted acceptor; this module has no makeTcpAcceptor helper.
• startListening creates and configures the listening socket. A successful call leaves the object in LISTENING state.
• AcceptEx is an exported FN_ACCEPTEXRef slot. startListening resolves it through WSAIoctl when it is nil.
• The module uses the completion port exported by windows/dispatcher; the dispatcher module initializes Winsock and that completion port at program startup.
• DIE atomically enters its destruction state and asserts that the state was 0n8. Callers must stop listening and finish or cancel an operation before destruction; DIE does not close an active listener.

Methods

Callback and dispatcher model

• accept does not wait for a connection and does not return an address or connection directly. The immediate result reports only whether the AcceptEx operation was initiated.
• dispatcher.dispatch or dispatcher.tryDispatch handles one completion-port entry. The dispatcher calls the stored onAcceptEvent with transferred bytes and a completion error; the source asserts that the transferred count is zero for this zero-receive accept.
• On a successful completion, the source updates the accepted socket with SO_UPDATE_ACCEPT_CONTEXT, associates it with the completion port, calls TcpConnection.setConnection, and invokes onAccept.
• On a failed completion, the source closes the accepted socket and passes either "canceled" for ERROR_OPERATION_ABORTED or "AcceptEx failed, result=" followed by the error code.
• The state bits are IN_DIE=0x01n8, IN_START_LISTENING=0x02n8, IN_STOP_LISTENING=0x04n8, IN_ACCEPT=0x08n8, IN_CANCEL=0x10n8, IN_ON_ACCEPT_EVENT=0x20n8, LISTENING=0x40n8, and ACCEPTING=0x80n8.

This callback/dispatcher path differs from sync/TcpAcceptor, whose accept waits in a fiber and returns a connection, address, and result directly.

Ownership and threading

• The acceptor owns its listening socket after successful startListening and closes it in stopListening. A failed setup path closes the temporary socket and stores zero state.
• The accepted socket remains in the acceptor's pending-connection field until completion. On successful completion, TcpConnection.setConnection installs it in the connection wrapper before the callback is called.
• State transitions use atomicExchange, atomicStore, and atomicXor with the source's acquire/release markers. Invalid concurrent or out-of-order calls trigger the source assertions.
• The module creates no fiber and no worker thread. The thread that calls the dispatcher performs the callback when it dispatches the completion entry.
• The source warns that a caller must synchronize cancel with the return from accept; cancellation can race the transition into the pending operation.

Results and errors

• startListening reports setup errors as strings beginning with socket failed, result=, setsockopt failed, result=, bind failed, result=, listen failed, result=, WSAIoctl failed, result=, or CreateIoCompletionPort failed, result=.
• accept reports initiation errors with socket failed, result=, setsockopt failed, result=, or AcceptEx failed, result=.
• cancel prints a diagnostic when CancelIoEx fails except for ERROR_NOT_FOUND; the returned boolean is then FALSE.
• A failed closesocket prints a LEAK: closesocket failed, result= diagnostic. The source uses assertions for invalid state and callback contracts.

Examples

Windows dispatcher accept

This example does not compile with the checked mpl-sl revision (see the note above), so it carries no Expected Output.

"Function"              use
"String"                use
"control"               use
"windows/TcpAcceptor"   use
"windows/TcpConnection" use
"windows/dispatcher"    use

{} Int32 {} [
  acceptor: TcpAcceptor;
  onAccept: ({result: String Ref; connection: TcpConnection Ref;} {} {}) Function;
  callback: [connection: result:;;];
  @callback @onAccept.assign
  result: 0x7F000001n32 6614n16 @acceptor.startListening;
  [result.size 0 =] "startListening failed" ensure
  acceptResult: @onAccept @acceptor.accept;
  [acceptResult.size 0 =] "accept failed" ensure
  dispatcher.dispatch
  @acceptor.stopListening
  0
] "main" exportFunction

See also

• windows/dispatcher: Windows completion-port dispatcher and callback posting helpers.
• windows/TcpConnection: Windows completion-port TCP connection with asynchronous callbacks and cancellation.
• sync/TcpAcceptor: Listening TCP acceptor with address reporting and accepted connection creation.
• windows/ws2_32: Winsock2 declarations for sockets, overlapped I/O, and address-resolution helpers.