@fkn/lib/net

Classes

Server

Extends

• EventEmitter

Implements

• Server

Constructors

Constructor

new Server(options?, connectionListener?): Server;

Parameters

options?

ServerOpts & EventEmitterOptions & object

connectionListener?

(socket) => void

Returns

Server

Overrides

EventEmitter.constructor

Properties

connections

connections: number;

Implementation of

TCPServer.connections

listening

listening: boolean;

Indicates whether or not the server is listening for connections.

Since

v5.7.0

Implementation of

TCPServer.listening

maxConnections

maxConnections: number;

Set this property to reject connections when the server’s connection count gets high.

It is not recommended to use this option once a socket has been sent to a child with child_process.fork().

Since

v0.2.0

Implementation of

TCPServer.maxConnections

Methods

[asyncDispose]()

asyncDispose: Promise<void>;

Returns

Promise<void>

Implementation of

TCPServer.[asyncDispose]

address()

address(): string | AddressInfo | null;

Returns the bound address, the address family name, and port of the server as reported by the operating system if listening on an IP socket (useful to find which port was assigned when getting an OS-assigned address):{ port: 12346, family: 'IPv4', address: '127.0.0.1' }.

For a server listening on a pipe or Unix domain socket, the name is returned as a string.

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());
});

server.address() returns null before the 'listening' event has been emitted or after calling server.close().

Returns

string | AddressInfo | null

Since

v0.1.90

Implementation of

TCPServer.address

close()

close(callback?): this;

Stops the server from accepting new connections and keeps existing connections. This function is asynchronous, the server is finally closed when all connections are ended and the server emits a 'close' event. The optional callback will be called once the 'close' event occurs. Unlike that event, it will be called with an Error as its only argument if the server was not open when it was closed.

Parameters

callback?

(err?) => void

Called when the server is closed.

Returns

this

Since

v0.1.90

Implementation of

TCPServer.close

getConnections()

getConnections(cb): this;

Not implemented by the browser transport. This method throws.

Parameters

cb

(error, count) => void

Returns

this

Implementation of

TCPServer.getConnections

listen()

Call Signature

listen(
   port?,
   hostname?,
   backlog?,
   listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

port?

number

hostname?

string

backlog?

number

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(
   port?,
   hostname?,
   listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

port?

number

hostname?

string

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(
   port?,
   backlog?,
   listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

port?

number

backlog?

number

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(port?, listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

port?

number

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(
   path,
   backlog?,
   listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

path

string

backlog?

number

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(path, listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

path

string

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(options, listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

options

ListenOptions

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(
   handle,
   backlog?,
   listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

handle

any

backlog?

number

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(handle, listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

handle

any

listeningListener?

() => void

Returns

this

Implementation of

TCPServer.listen

Call Signature

listen(
   port?,
   hostname?,
   backlog?,
   listeningListener?): this;

Starts a TCP listener through WebVPN. Port and host forms are supported. IPC paths and existing Node handles are not supported and reject at runtime.

Parameters

port?

unknown

hostname?

unknown

backlog?

unknown

listeningListener?

unknown

Returns

this

Implementation of

TCPServer.listen

ref()

ref(): this;

No-op in a browser, which has no Node process-liveness handle.

Returns

this

Implementation of

TCPServer.ref

unref()

unref(): this;

No-op in a browser, which has no Node process-liveness handle.

Returns

this

Implementation of

TCPServer.unref

---

Socket

Extends

• Duplex

Implements

• Socket

Constructors

Constructor

new Socket(options?): Socket;

Parameters

options?

SocketConstructorOpts & DuplexOptions<Duplex> & object

Returns

Socket

Overrides

Stream.Duplex.constructor

Properties

autoSelectFamilyAttemptedAddresses

autoSelectFamilyAttemptedAddresses: string[];

This property is only present if the family autoselection algorithm is enabled in socket.connect(options) and it is an array of the addresses that have been attempted.

Each address is a string in the form of $IP:$PORT. If the connection was successful, then the last address is the one that the socket is currently connected to.

Since

v19.4.0

Implementation of

NetSocket.autoSelectFamilyAttemptedAddresses

bufferSize

bufferSize: number;

This property shows the number of characters buffered for writing. The buffer may contain strings whose length after encoding is not yet known. So this number is only an approximation of the number of bytes in the buffer.

net.Socket has the property that socket.write() always works. This is to help users get up and running quickly. The computer cannot always keep up with the amount of data that is written to a socket. The network connection simply might be too slow. Node.js will internally queue up the data written to a socket and send it out over the wire when it is possible.

The consequence of this internal buffering is that memory may grow. Users who experience large or growing bufferSize should attempt to “throttle” the data flows in their program with socket.pause() and socket.resume().

Since

v0.3.8

Deprecated

Since v14.6.0 - Use writableLength instead.

Implementation of

NetSocket.bufferSize

bytesRead

bytesRead: number;

The amount of received bytes.

Since

v0.5.3

Implementation of

NetSocket.bytesRead

bytesWritten

bytesWritten: number;

The amount of bytes sent.

Since

v0.5.3

Implementation of

NetSocket.bytesWritten

connecting

connecting: boolean;

If true, socket.connect(options[, connectListener]) was called and has not yet finished. It will stay true until the socket becomes connected, then it is set to false and the 'connect' event is emitted. Note that the socket.connect(options[, connectListener]) callback is a listener for the 'connect' event.

Since

v6.1.0

Implementation of

NetSocket.connecting

pending

pending: boolean;

This is true if the socket is not connected yet, either because .connect()has not yet been called or because it is still in the process of connecting (see socket.connecting).

Since

v11.2.0, v10.16.0

Implementation of

NetSocket.pending

readyState

readyState: "closed" | "opening" | "open" | "readOnly" | "writeOnly";

This property represents the state of the connection as a string.

• If the stream is connecting socket.readyState is opening.
• If the stream is readable and writable, it is open.
• If the stream is readable and not writable, it is readOnly.
• If the stream is not readable and writable, it is writeOnly.

Since

v0.5.0

Implementation of

NetSocket.readyState

timeout?

optional timeout?: number;

The socket timeout in milliseconds as set by socket.setTimeout(). It is undefined if a timeout has not been set.

Since

v10.7.0

Implementation of

NetSocket.timeout

Accessors

localAddress

Get Signature

get localAddress(): string;

The string representation of the local IP address the remote client is connecting on. For example, in a server listening on '0.0.0.0', if a client connects on '192.168.1.1', the value of socket.localAddress would be'192.168.1.1'.

Since

v0.9.6

Returns

string

Implementation of

NetSocket.localAddress

localFamily

Get Signature

get localFamily(): string;

The string representation of the local IP family. 'IPv4' or 'IPv6'.

Since

v18.8.0, v16.18.0

Returns

string

Implementation of

NetSocket.localFamily

localPort

Get Signature

get localPort(): number;

The numeric representation of the local port. For example, 80 or 21.

Since

v0.9.6

Returns

number

Implementation of

NetSocket.localPort

remoteAddress

Get Signature

get remoteAddress(): string;

The string representation of the remote IP address. For example,'74.125.127.100' or '2001:4860:a005::68'. Value may be undefined if the socket is destroyed (for example, if the client disconnected).

Since

v0.5.10

Returns

string

Implementation of

NetSocket.remoteAddress

remoteFamily

Get Signature

get remoteFamily(): string;

The string representation of the remote IP family. 'IPv4' or 'IPv6'. Value may be undefined if the socket is destroyed (for example, if the client disconnected).

Since

v0.11.14

Returns

string

Implementation of

NetSocket.remoteFamily

remotePort

Get Signature

get remotePort(): number;

The numeric representation of the remote port. For example, 80 or 21. Value may be undefined if the socket is destroyed (for example, if the client disconnected).

Since

v0.5.10

Returns

number

Implementation of

NetSocket.remotePort

Methods

address()

address():
  | {
}
  | AddressInfo;

Returns the bound address, the address family name and port of the socket as reported by the operating system:{ port: 12346, family: 'IPv4', address: '127.0.0.1' }

Returns

| { } | AddressInfo

Since

v0.1.90

Implementation of

NetSocket.address

connect()

Call Signature

connect(options, connectionListener?): this;

SOCKET IMPL

Parameters

options

SocketConnectOpts

connectionListener?

() => void

Returns

this

Implementation of

NetSocket.connect

Call Signature

connect(
   port,
   host,
   connectionListener?): this;

SOCKET IMPL

Parameters

port

number

host

string

connectionListener?

() => void

Returns

this

Implementation of

NetSocket.connect

Call Signature

connect(port, connectionListener?): this;

SOCKET IMPL

Parameters

port

number

connectionListener?

() => void

Returns

this

Implementation of

NetSocket.connect

Call Signature

connect(path, connectionListener?): this;

SOCKET IMPL

Parameters

path

string

connectionListener?

() => void

Returns

this

Implementation of

NetSocket.connect

Call Signature

connect(
   port,
   host?,
   connectionListener?): this;

SOCKET IMPL

Parameters

port

unknown

host?

unknown

connectionListener?

unknown

Returns

this

Implementation of

NetSocket.connect

destroySoon()

destroySoon(): void;

Destroys the socket after all data is written. If the finish event was already emitted the socket is destroyed immediately. If the socket is still writable it implicitly calls socket.end().

Returns

void

Since

v0.3.4

Implementation of

NetSocket.destroySoon

getTypeOfService()

getTypeOfService(): number;

Returns

number

ref()

ref(): this;

Opposite of unref(), calling ref() on a previously unrefed socket will not let the program exit if it’s the only socket left (the default behavior). If the socket is refed calling ref again will have no effect.

Returns

this

The socket itself.

Since

v0.9.1

Implementation of

NetSocket.ref

resetAndDestroy()

resetAndDestroy(): this;

Close the TCP connection by sending an RST packet and destroy the stream. If this TCP socket is in connecting status, it will send an RST packet and destroy this TCP socket once it is connected. Otherwise, it will call socket.destroy with an ERR_SOCKET_CLOSED Error. If this is not a TCP socket (for example, a pipe), calling this method will immediately throw an ERR_INVALID_HANDLE_TYPE Error.

Returns

this

Since

v18.3.0, v16.17.0

Implementation of

NetSocket.resetAndDestroy

setKeepAlive()

setKeepAlive(enable?, initialDelay?): this;

Enable/disable keep-alive functionality, and optionally set the initial delay before the first keepalive probe is sent on an idle socket.

Set initialDelay (in milliseconds) to set the delay between the last data packet received and the first keepalive probe. Setting 0 forinitialDelay will leave the value unchanged from the default (or previous) setting.

Enabling the keep-alive functionality will set the following socket options:

• SO_KEEPALIVE=1
• TCP_KEEPIDLE=initialDelay
• TCP_KEEPCNT=10
• TCP_KEEPINTVL=1

Parameters

enable?

boolean

initialDelay?

number

Returns

this

The socket itself.

Since

v0.1.92

Implementation of

NetSocket.setKeepAlive

setNoDelay()

setNoDelay(noDelay?): this;

Enable/disable the use of Nagle’s algorithm.

When a TCP connection is created, it will have Nagle’s algorithm enabled.

Nagle’s algorithm delays data before it is sent via the network. It attempts to optimize throughput at the expense of latency.

Passing true for noDelay or not passing an argument will disable Nagle’s algorithm for the socket. Passing false for noDelay will enable Nagle’s algorithm.

Parameters

noDelay?

boolean

Returns

this

The socket itself.

Since

v0.1.90

Implementation of

NetSocket.setNoDelay

setRecvBufferSize()

setRecvBufferSize(size): this;

Parameters

size

number

Returns

this

setSendBufferSize()

setSendBufferSize(size): this;

Parameters

size

number

Returns

this

setTimeout()

setTimeout(timeout, callback?): this;

Sets the socket to timeout after timeout milliseconds of inactivity on the socket. By default net.Socket do not have a timeout.

When an idle timeout is triggered the socket will receive a 'timeout' event but the connection will not be severed. The user must manually call socket.end() or socket.destroy() to end the connection.

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

If timeout is 0, then the existing idle timeout is disabled.

The optional callback parameter will be added as a one-time listener for the 'timeout' event.

Parameters

timeout

number

callback?

() => void

Returns

this

The socket itself.

Since

v0.1.90

Implementation of

NetSocket.setTimeout

setTypeOfService()

setTypeOfService(tos): this;

Parameters

tos

number

Returns

this

unref()

unref(): this;

Calling unref() on a socket will allow the program to exit if this is the only active socket in the event system. If the socket is already unrefed callingunref() again will have no effect.

Returns

this

The socket itself.

Since

v0.9.1

Implementation of

NetSocket.unref

write()

Call Signature

write(buffer, cb?): boolean;

The writable.write() method writes some data to the stream, and calls the supplied callback once the data has been fully handled. If an error occurs, the callback will be called with the error as its first argument. The callback is called asynchronously and before 'error' is emitted.

The return value is true if the internal buffer is less than the highWaterMark configured when the stream was created after admitting chunk. If false is returned, further attempts to write data to the stream should stop until the 'drain' event is emitted.

While a stream is not draining, calls to write() will buffer chunk, and return false. Once all currently buffered chunks are drained (accepted for delivery by the operating system), the 'drain' event will be emitted. Once write() returns false, do not write more chunks until the 'drain' event is emitted. While calling write() on a stream that is not draining is allowed, Node.js will buffer all written chunks until maximum memory usage occurs, at which point it will abort unconditionally. Even before it aborts, high memory usage will cause poor garbage collector performance and high RSS (which is not typically released back to the system, even after the memory is no longer required). Since TCP sockets may never drain if the remote peer does not read the data, writing a socket that is not draining can keep buffering until the process runs out of memory.

Writing data while the stream is not draining is particularly problematic for a Transform, because the Transform streams are paused by default until they are piped or a 'data' or 'readable' event handler is added.

If the data to be written can be generated or fetched on demand, it is recommended to encapsulate the logic into a Readable and use pipe. However, if calling write() is preferred, it is possible to respect backpressure and avoid memory issues using the 'drain' event:

function write(data, cb) {
  if (!stream.write(data)) {
    stream.once('drain', cb);
  } else {
    process.nextTick(cb);
  }
}

// Wait for cb to be called before doing any other write.
write('hello', () => {
  console.log('Write completed, do more writes now.');
});

A Writable stream in object mode will always ignore the encoding argument.

Parameters

buffer

string | Uint8Array<ArrayBufferLike>

cb?

(err?) => void

Returns

boolean

false if the stream wishes for the calling code to wait for the 'drain' event to be emitted before continuing to write additional data; otherwise true.

Since

v0.9.4

Implementation of

NetSocket.write

Overrides

Stream.Duplex.write

Call Signature

write(
   str,
   encoding?,
   cb?): boolean;

Parameters

str

string | Uint8Array<ArrayBufferLike>

encoding?

BufferEncoding

cb?

(err?) => void

Returns

boolean

Implementation of

NetSocket.write

Overrides

Stream.Duplex.write

Variables

_default

const _default: object;

Type Declaration

connect

connect: (options, connectionListener?) => Socket;

Parameters

options

SocketConnectOpts

connectionListener?

() => void

Returns

Socket

createConnection

createConnection: (options, connectionListener?) => Socket;

Parameters

options

SocketConnectOpts

connectionListener?

() => void

Returns

Socket

createServer

createServer: (options?, connectionListener?) => Server;

Parameters

options?

ServerOpts | ((socket) => void)

connectionListener?

(socket) => void

Returns

Server

isIP

isIP: (input) => 0 | 4 | 6;

Parameters

input

string

Returns

0 | 4 | 6

isIPv4

isIPv4: (input) => boolean;

Parameters

input

string

Returns

boolean

isIPv6

isIPv6: (input) => boolean;

Parameters

input

string

Returns

boolean

Server

Server: typeof Server;

Socket

Socket: typeof Socket;

Functions

connect()

function connect(options, connectionListener?): Socket;

Parameters

options

SocketConnectOpts

connectionListener?

() => void

Returns

Socket

---

createConnection()

function createConnection(options, connectionListener?): Socket;

Parameters

options

SocketConnectOpts

connectionListener?

() => void

Returns

Socket

---

createServer()

function createServer(options?, connectionListener?): Server;

Parameters

options?

ServerOpts | ((socket) => void)

connectionListener?

(socket) => void

Returns

Server

References

default

Renames and re-exports _default

---

isIP

Re-exports isIP

---

isIPv4

Re-exports isIPv4

---

isIPv6

Re-exports isIPv6