IPC support #

Identifying paths for IPC connections #

net.connect() , net.createConnection() , server.listen() , and socket.connect() take a path parameter to identify IPC endpoints.

On Unix, the local domain is also known as the Unix domain. The path is a file system pathname. It gets truncated to an OS-dependent length of sizeof(sockaddr_un.sun_path) - 1 . Typical values are 107 bytes on Linux and 103 bytes on macOS. If a Node.js API abstraction creates the Unix domain socket, it will unlink the Unix domain socket as well. For example, net.createServer() may create a Unix domain socket and server.close() will unlink it. But if a user creates the Unix domain socket outside of these abstractions, the user will need to remove it. The same applies when a Node.js API creates a Unix domain socket but the program then crashes. In short, a Unix domain socket will be visible in the file system and will persist until unlinked.

On Windows, the local domain is implemented using a named pipe. The path must refer to an entry in \\?\pipe\ or \\.\pipe\ . Any characters are permitted, but the latter may do some processing of pipe names, such as resolving .. sequences. Despite how it might look, the pipe namespace is flat. Pipes will not persist . They are removed when the last reference to them is closed. Unlike Unix domain sockets, Windows will close and remove the pipe when the owning process exits.

JavaScript string escaping requires paths to be specified with extra backslash escaping such as:

net.createServer().listen(
  path.join('\\\\?\\pipe', process.cwd(), 'myctl')); copy

Class: net.BlockList #

blockList.addAddress(address[, type]) #

Adds a rule to block the given IP address.

blockList.addRange(start, end[, type]) #

Adds a rule to block a range of IP addresses from start (inclusive) to end (inclusive).

blockList.addSubnet(net, prefix[, type]) #

Adds a rule to block a range of IP addresses specified as a subnet mask.

blockList.check(address[, type]) #

Returns true if the given IP address matches any of the rules added to the BlockList .

const blockList = new net.BlockList();
blockList.addAddress('123.123.123.123');
blockList.addRange('10.0.0.1', '10.0.0.10');
blockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');
console.log(blockList.check('123.123.123.123'));  // Prints: true
console.log(blockList.check('10.0.0.3'));  // Prints: true
console.log(blockList.check('222.111.111.222'));  // Prints: false
// IPv6 notation for IPv4 addresses works:
console.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true
console.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true copy

blockList.rules #

The list of rules added to the blocklist.

Class: net.SocketAddress #

new net.SocketAddress([options]) #

socketaddress.address #

socketaddress.family #

socketaddress.flowlabel #

socketaddress.port #

Class: net.Server #

This class is used to create a TCP or IPC server.

new net.Server([options][, connectionListener]) #

net.Server is an EventEmitter with the following events:

Event: 'close' #

Event: 'connection' #

Emitted when a new connection is made. socket is an instance of net.Socket .

Event: 'error' #

Emitted when an error occurs. Unlike net.Socket , the 'close' event will not be emitted directly following this event unless server.close() is manually called. See the example in discussion of server.listen() .

Event: 'listening' #

Emitted when the server has been bound after calling server.listen() .

Event: 'drop' #

server.address() #

const server = net.createServer((socket) => {
  socket.end('goodbye\n');
}).on('error', (err) => {
  // Handle errors here.
  throw err;
// Grab an arbitrary unused port.
server.listen(() => {
  console.log('opened server on', server.address());
}); copy

server.on('error', (e) => {
  if (e.code === 'EADDRINUSE') {
    console.error('Address in use, retrying...');
    setTimeout(() => {
      server.close();
      server.listen(PORT, HOST);
    }, 1000);
}); copy

server.listen({
  host: 'localhost',
  port: 80,
  exclusive: true,
}); copy

const controller = new AbortController();
server.listen({
  host: 'localhost',
  port: 80,
  signal: controller.signal,
// Later, when you want to close the server.
controller.abort(); copy

Class: net.Socket #

This class is an abstraction of a TCP socket or a streaming IPC endpoint (uses named pipes on Windows, and Unix domain sockets otherwise). It is also an EventEmitter .

A net.Socket can be created by the user and used directly to interact with a server. For example, it is returned by net.createConnection() , so the user can use it to talk to the server.

It can also be created by Node.js and passed to the user when a connection is received. For example, it is passed to the listeners of a 'connection' event emitted on a net.Server , so the user can use it to interact with the client.

new net.Socket([options]) #

const net = require('node:net');
net.connect({
  port: 80,
  onread: {
    // Reuses a 4KiB Buffer for every read from the socket.
    buffer: Buffer.alloc(4 * 1024),
    callback: function(nread, buf) {
      // Received data is available in `buf` from 0 to `nread`.
      console.log(buf.toString('utf8', 0, nread));
}); copy

socket.setTimeout(3000);
socket.on('timeout', () => {
  console.log('socket timeout');
  socket.end();
}); copy

net.connect() #

Aliases to net.createConnection() .

Possible signatures:

net.connect(options[, connectListener]) #

Alias to net.createConnection(options[, connectListener]) .

net.connect(path[, connectListener]) #

Alias to net.createConnection(path[, connectListener]) .

net.connect(port[, host][, connectListener]) #

Alias to net.createConnection(port[, host][, connectListener]) .

net.createConnection() #

A factory function, which creates a new net.Socket , immediately initiates connection with socket.connect() , then returns the net.Socket that starts the connection.

When the connection is established, a 'connect' event will be emitted on the returned socket. The last parameter connectListener , if supplied, will be added as a listener for the 'connect' event once .

Possible signatures:

The net.connect() function is an alias to this function.

net.createConnection(options[, connectListener]) #

For available options, see new net.Socket([options]) and socket.connect(options[, connectListener]) .

Additional options:

Following is an example of a client of the echo server described in the net.createServer() section:

const net = require('node:net');
const client = net.createConnection({ port: 8124 }, () => {
  // 'connect' listener.
  console.log('connected to server!');
  client.write('world!\r\n');
client.on('data', (data) => {
  console.log(data.toString());
  client.end();
client.on('end', () => {
  console.log('disconnected from server');
}); copy

To connect on the socket /tmp/echo.sock :

const client = net.createConnection({ path: '/tmp/echo.sock' }); copy

net.createConnection(path[, connectListener]) #

Initiates an IPC connection.

This function creates a new net.Socket with all options set to default, immediately initiates connection with socket.connect(path[, connectListener]) , then returns the net.Socket that starts the connection.

net.createConnection(port[, host][, connectListener]) #

Initiates a TCP connection.

This function creates a new net.Socket with all options set to default, immediately initiates connection with socket.connect(port[, host][, connectListener]) , then returns the net.Socket that starts the connection.

net.createServer([options][, connectionListener]) #

const net = require('node:net');
const server = net.createServer((c) => {
  // 'connection' listener.
  console.log('client connected');
  c.on('end', () => {
    console.log('client disconnected');
  c.write('hello\r\n');
  c.pipe(c);
server.on('error', (err) => {
  throw err;
server.listen(8124, () => {
  console.log('server bound');
}); copy

telnet localhost 8124 copy

server.listen('/tmp/echo.sock', () => {
  console.log('server bound');
}); copy

nc -U /tmp/echo.sock copy

net.getDefaultAutoSelectFamily() #

Gets the current default value of the autoSelectFamily option of socket.connect(options) . The initial default value is true , unless the command line option --no-network-family-autoselection is provided.

net.setDefaultAutoSelectFamily(value) #

Sets the default value of the autoSelectFamily option of socket.connect(options) .

net.getDefaultAutoSelectFamilyAttemptTimeout() #

Gets the current default value of the autoSelectFamilyAttemptTimeout option of socket.connect(options) . The initial default value is 250 .

net.setDefaultAutoSelectFamilyAttemptTimeout(value) #

Sets the default value of the autoSelectFamilyAttemptTimeout option of socket.connect(options) .

net.isIP(input) #

Returns 6 if input is an IPv6 address. Returns 4 if input is an IPv4 address in dot-decimal notation with no leading zeroes. Otherwise, returns

net.isIP('::1'); // returns 6
net.isIP('127.0.0.1'); // returns 4
net.isIP('127.000.000.001'); // returns 0
net.isIP('127.0.0.1/24'); // returns 0
net.isIP('fhqwhgads'); // returns 0 copy

net.isIPv4(input) #

Returns true if input is an IPv4 address in dot-decimal notation with no leading zeroes. Otherwise, returns false .

net.isIPv4('127.0.0.1'); // returns true
net.isIPv4('127.000.000.001'); // returns false
net.isIPv4('127.0.0.1/24'); // returns false
net.isIPv4('fhqwhgads'); // returns false copy

net.isIPv6(input) #

Returns true if input is an IPv6 address. Otherwise, returns false .

net.isIPv6('::1'); // returns true
net.isIPv6('fhqwhgads'); // returns false copy