accept — Accept a pending TCP client connection from a RunMat server listener.
accept(server) waits for a pending connection on a socket created by tcpserver. It returns a client value carrying TCP client-style metadata for read, write, and close.
Syntax
client = accept(server)
client = accept(server, "Timeout", timeout)
client = accept(server, Name, Value, ...)Inputs
server- Type
Any- Required
- Yes
- Description
- tcpserver object returned by tcpserver.
name- Type
StringScalar- Required
- Yes
- Default
"Timeout"- Description
- Name token. Supported value: "Timeout".
timeout- Type
NumericScalar- Required
- Yes
- Description
- Per-call accept timeout in seconds (non-negative, supports Inf).
name_value_pairs- Type
Any- Required
- Variadic
- Description
- Name/Value option pairs (currently Timeout only).
Returns
client- Type
Any- Description
- tcpclient object with sealed authority for the accepted connection.
Errors
RunMat:network:UnsupportedTarget- When
- A native TCP socket operation is requested in a browser target.
- Message
native TCP sockets are unavailable on this target
RunMat:Cancelled- When
- An invocation is cancelled before or during a pending TCP operation.
- Message
TCP invocation was cancelled
RunMat:accept:InvalidTcpServer- When
- Server argument is missing/invalid or references a stale tcpserver handle.
- Message
accept: invalid tcpserver handle
Server and timeout
The first argument must be the current RunMat server value returned by tcpserver. An invalid, missing, or stale listener yields RunMat:accept:InvalidTcpServer.
By default, accept uses the timeout captured when the server was created. Override it per call with accept(server, "Timeout", seconds). The timeout is nonnegative; NaN, negative, nonscalar, or unsupported Name/Value controls raise RunMat:accept:InvalidNameValue.
If no client connects before a finite timeout, accept raises RunMat:accept:Timeout. Other OS accept failures raise RunMat:accept:AcceptFailed with the underlying error detail.
Result and host execution
The RunMat result is a tcpclient object with visible properties such as Address, Port, NumBytesAvailable, ByteOrder, Timeout, UserData, and Connected. A sealed session-owned socket authority is not exposed as a public property. The accepted peer Port is stored as uint16, unlike the double port property on a directly constructed client. This does not implement MATLAB handle-class behavior.
The socket wait executes on the host. Resident server or timeout controls gather through their owner before waiting; no accelerator kernel performs network I/O. A successful call creates a separate accepted client while the server remains available for later accepts.
The operating-system backlog determines how many connections can queue. Use close(client) to release an accepted socket and close(server) to release the listener. TLS is not supported by this plain TCP route.
Illustrative programs
Accepting a localhost client
srv = tcpserver("127.0.0.1", 0);
port = srv.ServerPort;
tcpclient("127.0.0.1", port);
client = accept(srv);
disp(client.Address)
disp(client.Port)
Illustrative display: 127.0.0.1
55000 (actual peer port varies)
Overriding one accept timeout
srv = tcpserver("0.0.0.0", 0, "Timeout", 10);
try
client = accept(srv, "Timeout", 0.25);
catch err
disp(err.identifier)
end
Expected identifier without a connecting peer: RunMat:accept:Timeout
Inspecting connection metadata
srv = tcpserver("::1", 45000);
tcpclient("::1", 45000);
client = accept(srv);
fprintf("Remote peer %s:%d\n", client.Address, client.Port);
fprintf("Byte order: %s\n", client.ByteOrder)
Illustrative display: Remote peer ::1:51432
Byte order: little-endian (peer port varies)
Handling multiple queued clients sequentially
srv = tcpserver("127.0.0.1", 47000);
tcpclient("127.0.0.1", 47000);
tcpclient("127.0.0.1", 47000);
client1 = accept(srv);
client2 = accept(srv);
fprintf("First connection from %s\n", client1.Address);
fprintf("Second connection from %s\n", client2.Address)
Expected display: First connection from 127.0.0.1
Second connection from 127.0.0.1
Inspecting accepted peer metadata
srv = tcpserver("127.0.0.1", 52000);
tcpclient("127.0.0.1", 52000);
client = accept(srv);
fprintf("Accepted peer %s:%d\n", client.Address, client.Port)
Illustrative display: Accepted peer 127.0.0.1:51432 (peer port varies; socket authority is not a public property)
Example
Accept a queued local connection
srv = tcpserver('127.0.0.1', 0);
port = srv.ServerPort;
outbound = tcpclient('127.0.0.1', port);
inbound = accept(srv, 'Timeout', 1);
assert(inbound.Connected);
assert(strcmp(inbound.Address, '127.0.0.1'));
close(inbound);
close(outbound);
close(srv);Using accept with coding agents
Open a RunMat example with live inputs, then ask the agent to explain how accept changes the result.
Run a small accept example, explain the result, then change one input and compare the output.
FAQ
What happens if the server is invalid or closed?⌄
RunMat reports RunMat:accept:InvalidTcpServer. Pass a live value returned by tcpserver.
Can I accept multiple clients with the same server?⌄
Yes. Call accept repeatedly; each success registers a separate client while keeping the listener active.
How do I change the timeout globally?⌄
Set Timeout when constructing tcpserver; override one call with accept(srv, "Timeout", value).
Does RunMat support IPv6 clients?⌄
Yes. IPv4 and IPv6 peer addresses are recorded as text in the returned client’s Address field.
Is there a queue limit for pending connections?⌄
The OS backlog applies; a full queue can refuse new connections before accept sees them.
Can I use accept in parallel workers?⌄
Socket authority belongs to the creating session and is not portable to another worker. Create the listener in the worker that will accept its clients.
How do I close the accepted client?⌄
Call close(client) for deterministic release. The final owner or session teardown also retires its socket authority.
What does NumBytesAvailable represent?⌄
It is initially zero in the returned snapshot. The current value is not a live view of changing socket buffer state.
Does the builtin support TLS?⌄
No. This route supports plain TCP only.
Related Io functions
Repl Fs
addpath · cd · copyfile · delete · dir · exist · fileattrib · fileparts · filesep · fullfile · genpath · getenv · getpref · isenv · isfile · isfolder · ispref · ls · matlabroot · memmapfile · memmapfile.subsasgn · memmapfile.subsref · mkdir · movefile · open · opentoline · path · pathsep · pcode · pwd · readstruct · rehash · restoredefaultpath · rmdir · rmpath · run · savepath · setenv · setpref · system · tempdir · tempname · uigetdir · uigetfile · uiputfile · unsetenv · userpath · what · winqueryreg · xmlread · xmlwrite
Tabular
arrayDatastore · csvread · csvwrite · detectImportOptions · dlmread · dlmwrite · fileDatastore · getvaropts · parquetDatastore · parquetinfo · parquetread · readcell · readmatrix · readtable · readtimetable · setvaropts · setvartype · spreadsheetImportOptions · writecell · writematrix · writetable · writetimetable · xlsread · xlswrite
Data
commit · data.copy · data.create · data.delete · data.exists · data.export · data.import · data.inspect · data.list · data.move · data.open · DataArray.chunk_shape · DataArray.codec · DataArray.dtype · DataArray.fill · DataArray.name · DataArray.rank · DataArray.read · DataArray.resize · DataArray.shape · DataArray.write · Dataset.array · Dataset.arrays · Dataset.attrs · Dataset.begin · Dataset.get_attr · Dataset.has_array · Dataset.id · Dataset.path · Dataset.refresh · Dataset.set_attr · Dataset.set_attrs · Dataset.snapshot · Dataset.version · DataTransaction.abort · DataTransaction.commit · DataTransaction.create_array · DataTransaction.delete_array · DataTransaction.fill · DataTransaction.id · DataTransaction.resize · DataTransaction.set_attr · DataTransaction.set_attrs · DataTransaction.status · DataTransaction.write
Filetext
fclose · feof · fgetl · fgets · fileread · filewrite · fopen · fprintf · fread · frewind · fwrite · readlines · writelines
Import
Json
Source you can read
Every RunMat function's source is public. Read exactly how accept is executed, line by line, in Rust.
- View the source for accept in Rust on GitHub
- Learn how the RunMat runtime works
- Found a bug? Open an issue with a minimal reproduction.
About RunMat
RunMat is a runtime that executes MATLAB-syntax code fast on any GPU. The runtime is free for individuals, including freelancers; students and faculty at an academic institution, for teaching or research there; contributors to an open-source project, for work on that project; organizations with 250 or fewer people and US$10M or less in annual revenue; and anyone, for non-production use. See runmat.com/license.
- RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
- Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.