2021-09-29 18:17:34 +02:00
2022-04-10 02:18:16 +02:00
/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
2021-09-29 18:17:34 +02:00
2023-03-03 11:55:06 +01:00
/ * *
* > Stability : 2 - Stable
*
* The ` net ` module provides an asynchronous network API for creating stream - based
* TCP or ` IPC ` servers ( { @link createServer } ) and clients
* ( { @link createConnection } ) .
*
* It can be accessed using :
*
* ` ` ` js
* const net = require ( 'net' ) ;
* ` ` `
* @see [ source ] ( https : //github.com/nodejs/node/blob/v16.9.0/lib/net.js)
* /
2021-09-29 18:17:34 +02:00
declare module 'net' {
2023-03-03 11:55:06 +01:00
import * as stream from 'node:stream' ;
import { Abortable , EventEmitter } from 'node:events' ;
import * as dns from 'node:dns' ;
type LookupFunction = ( hostname : string , options : dns.LookupOneOptions , callback : ( err : NodeJS.ErrnoException | null , address : string , family : number ) = > void ) = > void ;
2021-09-29 18:17:34 +02:00
interface AddressInfo {
address : string ;
family : string ;
port : number ;
}
interface SocketConstructorOpts {
fd? : number | undefined ;
allowHalfOpen? : boolean | undefined ;
readable? : boolean | undefined ;
writable? : boolean | undefined ;
2023-03-03 11:55:06 +01:00
signal? : AbortSignal ;
2021-09-29 18:17:34 +02:00
}
interface OnReadOpts {
buffer : Uint8Array | ( ( ) = > Uint8Array ) ;
/ * *
* This function is called for every chunk of incoming data .
* Two arguments are passed to it : the number of bytes written to buffer and a reference to buffer .
* Return false from this function to implicitly pause ( ) the socket .
* /
callback ( bytesWritten : number , buf : Uint8Array ) : boolean ;
}
interface ConnectOpts {
/ * *
* If specified , incoming data is stored in a single buffer and passed to the supplied callback when data arrives on the socket .
* Note : this will cause the streaming functionality to not provide any data , however events like 'error' , 'end' , and 'close' will
* still be emitted as normal and methods like pause ( ) and resume ( ) will also behave as expected .
* /
onread? : OnReadOpts | undefined ;
}
interface TcpSocketConnectOpts extends ConnectOpts {
port : number ;
host? : string | undefined ;
localAddress? : string | undefined ;
localPort? : number | undefined ;
hints? : number | undefined ;
family? : number | undefined ;
lookup? : LookupFunction | undefined ;
2023-03-03 11:55:06 +01:00
noDelay? : boolean | undefined ;
keepAlive? : boolean | undefined ;
keepAliveInitialDelay? : number | undefined ;
2021-09-29 18:17:34 +02:00
}
interface IpcSocketConnectOpts extends ConnectOpts {
path : string ;
}
type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts ;
2023-03-03 11:55:06 +01:00
type SocketReadyState = 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed' ;
/ * *
* 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 { @link 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 { @link Server } , so the user can use
* it to interact with the client .
* @since v0 . 3.4
* /
2021-09-29 18:17:34 +02:00
class Socket extends stream . Duplex {
constructor ( options? : SocketConstructorOpts ) ;
2023-03-03 11:55:06 +01:00
/ * *
* Sends data on the socket . The second parameter specifies the encoding in the
* case of a string . It defaults to UTF8 encoding .
*
* Returns ` true ` if the entire data was flushed successfully to the kernel
* buffer . Returns ` false ` if all or part of the data was queued in user memory . ` 'drain' ` will be emitted when the buffer is again free .
*
* The optional ` callback ` parameter will be executed when the data is finally
* written out , which may not be immediately .
*
* See ` Writable ` stream ` write() ` method for more
* information .
* @since v0 . 1.90
* @param [ encoding = 'utf8' ] Only used when data is ` string ` .
* /
2021-09-29 18:17:34 +02:00
write ( buffer : Uint8Array | string , cb ? : ( err? : Error ) = > void ) : boolean ;
write ( str : Uint8Array | string , encoding? : BufferEncoding , cb ? : ( err? : Error ) = > void ) : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* Initiate a connection on a given socket .
*
* Possible signatures :
*
* * ` socket.connect(options[, connectListener]) `
* * ` socket.connect(path[, connectListener]) ` for ` IPC ` connections .
* * ` socket.connect(port[, host][, connectListener]) ` for TCP connections .
* * Returns : ` net.Socket ` The socket itself .
*
* This function is asynchronous . When the connection is established , the ` 'connect' ` event will be emitted . If there is a problem connecting ,
* instead of a ` 'connect' ` event , an ` 'error' ` event will be emitted with
* the error passed to the ` 'error' ` listener .
* The last parameter ` connectListener ` , if supplied , will be added as a listener
* for the ` 'connect' ` event * * once * * .
*
* This function should only be used for reconnecting a socket after ` 'close' ` has been emitted or otherwise it may lead to undefined
* behavior .
* /
2021-09-29 18:17:34 +02:00
connect ( options : SocketConnectOpts , connectionListener ? : ( ) = > void ) : this ;
connect ( port : number , host : string , connectionListener ? : ( ) = > void ) : this ;
connect ( port : number , connectionListener ? : ( ) = > void ) : this ;
connect ( path : string , connectionListener ? : ( ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* Set the encoding for the socket as a ` Readable Stream ` . See ` readable.setEncoding() ` for more information .
* @since v0 . 1.90
* @return The socket itself .
* /
2021-09-29 18:17:34 +02:00
setEncoding ( encoding? : BufferEncoding ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* Pauses the reading of data . That is , ` 'data' ` events will not be emitted .
* Useful to throttle back an upload .
* @return The socket itself .
* /
2021-09-29 18:17:34 +02:00
pause ( ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* Resumes reading after a call to ` socket.pause() ` .
* @return The socket itself .
* /
2021-09-29 18:17:34 +02:00
resume ( ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
*
* ` ` ` js
* 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 .
* @since v0 . 1.90
* @return The socket itself .
* /
2021-09-29 18:17:34 +02:00
setTimeout ( timeout : number , callback ? : ( ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* @since v0 . 1.90
* @param [ noDelay = true ]
* @return The socket itself .
* /
2021-09-29 18:17:34 +02:00
setNoDelay ( noDelay? : boolean ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 ` for ` initialDelay ` 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 `
* @since v0 . 1.92
* @param [ enable = false ]
* @param [ initialDelay = 0 ]
* @return The socket itself .
* /
2021-09-29 18:17:34 +02:00
setKeepAlive ( enable? : boolean , initialDelay? : number ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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' } `
* @since v0 . 1.90
* /
2021-09-29 18:17:34 +02:00
address ( ) : AddressInfo | { } ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 ` unref ` ed calling ` unref() ` again will have no effect .
* @since v0 . 9.1
* @return The socket itself .
* /
2021-09-29 18:17:34 +02:00
unref ( ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* Opposite of ` unref() ` , calling ` ref() ` on a previously ` unref ` ed socket will_not_ let the program exit if it ' s the only socket left ( the default behavior ) .
* If the socket is ` ref ` ed calling ` ref ` again will have no effect .
* @since v0 . 9.1
* @return The socket itself .
* /
2021-09-29 18:17:34 +02:00
ref ( ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* /
2021-09-29 18:17:34 +02:00
readonly bufferSize : number ;
2023-03-03 11:55:06 +01:00
/ * *
* The amount of received bytes .
* @since v0 . 5.3
* /
2021-09-29 18:17:34 +02:00
readonly bytesRead : number ;
2023-03-03 11:55:06 +01:00
/ * *
* The amount of bytes sent .
* @since v0 . 5.3
* /
2021-09-29 18:17:34 +02:00
readonly bytesWritten : number ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly connecting : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* See ` writable.destroyed ` for further details .
* /
2021-09-29 18:17:34 +02:00
readonly destroyed : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
readonly localAddress? : string ;
/ * *
* The numeric representation of the local port . For example , ` 80 ` or ` 21 ` .
* @since v0 . 9.6
* /
readonly localPort? : number ;
/ * *
* The string representation of the local IP family . ` 'IPv4' ` or ` 'IPv6' ` .
* @since v18 . 8.0 , v16 . 18.0
* /
readonly localFamily? : string ;
/ * *
* 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 v10 . 16.0
* /
readonly pending : boolean ;
/ * *
* This property represents the state of the connection as a string .
* @see { https : //nodejs.org/api/net.html#socketreadystate}
* @since v0 . 5.0
* /
readonly readyState : SocketReadyState ;
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
readonly remoteAddress? : string | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* The string representation of the remote IP family . ` 'IPv4' ` or ` 'IPv6' ` .
* @since v0 . 11.14
* /
2021-09-29 18:17:34 +02:00
readonly remoteFamily? : string | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* The numeric representation of the remote port . For example , ` 80 ` or ` 21 ` .
* @since v0 . 5.10
* /
2021-09-29 18:17:34 +02:00
readonly remotePort? : number | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* The socket timeout in milliseconds as set by socket . setTimeout ( ) . It is undefined if a timeout has not been set .
* @since v10 . 7.0
* /
readonly timeout? : number | undefined ;
/ * *
* Half - closes the socket . i . e . , it sends a FIN packet . It is possible the
* server will still send some data .
*
* See ` writable.end() ` for further details .
* @since v0 . 1.90
* @param [ encoding = 'utf8' ] Only used when data is ` string ` .
* @param callback Optional callback for when the socket is finished .
* @return The socket itself .
* /
end ( callback ? : ( ) = > void ) : this ;
end ( buffer : Uint8Array | string , callback ? : ( ) = > void ) : this ;
end ( str : Uint8Array | string , encoding? : BufferEncoding , callback ? : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
/ * *
* events . EventEmitter
* 1 . close
* 2 . connect
* 3 . data
* 4 . drain
* 5 . end
* 6 . error
* 7 . lookup
* 8 . timeout
* /
addListener ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
addListener ( event : 'close' , listener : ( hadError : boolean ) = > void ) : this ;
addListener ( event : 'connect' , listener : ( ) = > void ) : this ;
addListener ( event : 'data' , listener : ( data : Buffer ) = > void ) : this ;
addListener ( event : 'drain' , listener : ( ) = > void ) : this ;
addListener ( event : 'end' , listener : ( ) = > void ) : this ;
addListener ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
addListener ( event : 'lookup' , listener : ( err : Error , address : string , family : string | number , host : string ) = > void ) : this ;
addListener ( event : 'ready' , listener : ( ) = > void ) : this ;
addListener ( event : 'timeout' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
emit ( event : 'close' , hadError : boolean ) : boolean ;
emit ( event : 'connect' ) : boolean ;
emit ( event : 'data' , data : Buffer ) : boolean ;
emit ( event : 'drain' ) : boolean ;
emit ( event : 'end' ) : boolean ;
emit ( event : 'error' , err : Error ) : boolean ;
emit ( event : 'lookup' , err : Error , address : string , family : string | number , host : string ) : boolean ;
emit ( event : 'ready' ) : boolean ;
emit ( event : 'timeout' ) : boolean ;
2021-09-29 18:17:34 +02:00
on ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
on ( event : 'close' , listener : ( hadError : boolean ) = > void ) : this ;
on ( event : 'connect' , listener : ( ) = > void ) : this ;
on ( event : 'data' , listener : ( data : Buffer ) = > void ) : this ;
on ( event : 'drain' , listener : ( ) = > void ) : this ;
on ( event : 'end' , listener : ( ) = > void ) : this ;
on ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
on ( event : 'lookup' , listener : ( err : Error , address : string , family : string | number , host : string ) = > void ) : this ;
on ( event : 'ready' , listener : ( ) = > void ) : this ;
on ( event : 'timeout' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
once ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
once ( event : 'close' , listener : ( hadError : boolean ) = > void ) : this ;
once ( event : 'connect' , listener : ( ) = > void ) : this ;
once ( event : 'data' , listener : ( data : Buffer ) = > void ) : this ;
once ( event : 'drain' , listener : ( ) = > void ) : this ;
once ( event : 'end' , listener : ( ) = > void ) : this ;
once ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
once ( event : 'lookup' , listener : ( err : Error , address : string , family : string | number , host : string ) = > void ) : this ;
once ( event : 'ready' , listener : ( ) = > void ) : this ;
once ( event : 'timeout' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
prependListener ( event : 'close' , listener : ( hadError : boolean ) = > void ) : this ;
prependListener ( event : 'connect' , listener : ( ) = > void ) : this ;
prependListener ( event : 'data' , listener : ( data : Buffer ) = > void ) : this ;
prependListener ( event : 'drain' , listener : ( ) = > void ) : this ;
prependListener ( event : 'end' , listener : ( ) = > void ) : this ;
prependListener ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
prependListener ( event : 'lookup' , listener : ( err : Error , address : string , family : string | number , host : string ) = > void ) : this ;
prependListener ( event : 'ready' , listener : ( ) = > void ) : this ;
prependListener ( event : 'timeout' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
prependOnceListener ( event : 'close' , listener : ( hadError : boolean ) = > void ) : this ;
prependOnceListener ( event : 'connect' , listener : ( ) = > void ) : this ;
prependOnceListener ( event : 'data' , listener : ( data : Buffer ) = > void ) : this ;
prependOnceListener ( event : 'drain' , listener : ( ) = > void ) : this ;
prependOnceListener ( event : 'end' , listener : ( ) = > void ) : this ;
prependOnceListener ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
prependOnceListener ( event : 'lookup' , listener : ( err : Error , address : string , family : string | number , host : string ) = > void ) : this ;
prependOnceListener ( event : 'ready' , listener : ( ) = > void ) : this ;
prependOnceListener ( event : 'timeout' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
}
2023-03-03 11:55:06 +01:00
interface ListenOptions extends Abortable {
2021-09-29 18:17:34 +02:00
port? : number | undefined ;
host? : string | undefined ;
backlog? : number | undefined ;
path? : string | undefined ;
exclusive? : boolean | undefined ;
readableAll? : boolean | undefined ;
writableAll? : boolean | undefined ;
/ * *
* @default false
* /
ipv6Only? : boolean | undefined ;
}
interface ServerOpts {
/ * *
* Indicates whether half - opened TCP connections are allowed .
* @default false
* /
allowHalfOpen? : boolean | undefined ;
/ * *
* Indicates whether the socket should be paused on incoming connections .
* @default false
* /
pauseOnConnect? : boolean | undefined ;
2023-03-03 11:55:06 +01:00
/ * *
* If set to ` true ` , it disables the use of Nagle ' s algorithm immediately after a new incoming connection is received .
* @default false
* @since v16 . 5.0
* /
noDelay? : boolean | undefined ;
/ * *
* If set to ` true ` , it enables keep - alive functionality on the socket immediately after a new incoming connection is received ,
* similarly on what is done in ` socket.setKeepAlive([enable][, initialDelay]) ` .
* @default false
* @since v16 . 5.0
* /
keepAlive? : boolean | undefined ;
/ * *
* If set to a positive number , it sets the initial delay before the first keepalive probe is sent on an idle socket .
* @default 0
* @since v16 . 5.0
* /
keepAliveInitialDelay? : number | undefined ;
2021-09-29 18:17:34 +02:00
}
2023-03-03 11:55:06 +01:00
/ * *
* This class is used to create a TCP or ` IPC ` server .
* @since v0 . 1.90
* /
2021-09-29 18:17:34 +02:00
class Server extends EventEmitter {
constructor ( connectionListener ? : ( socket : Socket ) = > void ) ;
constructor ( options? : ServerOpts , connectionListener ? : ( socket : Socket ) = > void ) ;
2023-03-03 11:55:06 +01:00
/ * *
* Start a server listening for connections . A ` net.Server ` can be a TCP or
* an ` IPC ` server depending on what it listens to .
*
* Possible signatures :
*
* * ` server.listen(handle[, backlog][, callback]) `
* * ` server.listen(options[, callback]) `
* * ` server.listen(path[, backlog][, callback]) ` for ` IPC ` servers
* * ` server.listen([port[, host[, backlog]]][, callback]) ` for TCP servers
*
* This function is asynchronous . When the server starts listening , the ` 'listening' ` event will be emitted . The last parameter ` callback ` will be added as a listener for the ` 'listening' `
* event .
*
* All ` listen() ` methods can take a ` backlog ` parameter to specify the maximum
* length of the queue of pending connections . The actual length will be determined
* by the OS through sysctl settings such as ` tcp_max_syn_backlog ` and ` somaxconn ` on Linux . The default value of this parameter is 511 ( not 512 ) .
*
* All { @link Socket } are set to ` SO_REUSEADDR ` ( see [ ` socket(7) ` ] ( https : //man7.org/linux/man-pages/man7/socket.7.html) for
* details ) .
*
* The ` server.listen() ` method can be called again if and only if there was an
* error during the first ` server.listen() ` call or ` server.close() ` has been
* called . Otherwise , an ` ERR_SERVER_ALREADY_LISTEN ` error will be thrown .
*
* One of the most common errors raised when listening is ` EADDRINUSE ` .
* This happens when another server is already listening on the requested ` port ` / ` path ` / ` handle ` . One way to handle this would be to retry
* after a certain amount of time :
*
* ` ` ` js
* server . on ( 'error' , ( e ) = > {
* if ( e . code === 'EADDRINUSE' ) {
* console . log ( 'Address in use, retrying...' ) ;
* setTimeout ( ( ) = > {
* server . close ( ) ;
* server . listen ( PORT , HOST ) ;
* } , 1000 ) ;
* }
* } ) ;
* ` ` `
* /
2021-09-29 18:17:34 +02:00
listen ( port? : number , hostname? : string , backlog? : number , listeningListener ? : ( ) = > void ) : this ;
listen ( port? : number , hostname? : string , listeningListener ? : ( ) = > void ) : this ;
listen ( port? : number , backlog? : number , listeningListener ? : ( ) = > void ) : this ;
listen ( port? : number , listeningListener ? : ( ) = > void ) : this ;
listen ( path : string , backlog? : number , listeningListener ? : ( ) = > void ) : this ;
listen ( path : string , listeningListener ? : ( ) = > void ) : this ;
listen ( options : ListenOptions , listeningListener ? : ( ) = > void ) : this ;
listen ( handle : any , backlog? : number , listeningListener ? : ( ) = > void ) : this ;
listen ( handle : any , listeningListener ? : ( ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
* @since v0 . 1.90
* @param callback Called when the server is closed .
* /
2021-09-29 18:17:34 +02:00
close ( callback ? : ( err? : Error ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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 .
*
* ` ` ` js
* 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() ` .
* @since v0 . 1.90
* /
2021-09-29 18:17:34 +02:00
address ( ) : AddressInfo | string | null ;
2023-03-03 11:55:06 +01:00
/ * *
* Asynchronously get the number of concurrent connections on the server . Works
* when sockets were sent to forks .
*
* Callback should take two arguments ` err ` and ` count ` .
* @since v0 . 9.7
* /
2021-09-29 18:17:34 +02:00
getConnections ( cb : ( error : Error | null , count : number ) = > void ) : void ;
2023-03-03 11:55:06 +01:00
/ * *
* Opposite of ` unref() ` , calling ` ref() ` on a previously ` unref ` ed server will_not_ let the program exit if it ' s the only server left ( the default behavior ) .
* If the server is ` ref ` ed calling ` ref() ` again will have no effect .
* @since v0 . 9.1
* /
2021-09-29 18:17:34 +02:00
ref ( ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* Calling ` unref() ` on a server will allow the program to exit if this is the only
* active server in the event system . If the server is already ` unref ` ed calling ` unref() ` again will have no effect .
* @since v0 . 9.1
* /
2021-09-29 18:17:34 +02:00
unref ( ) : this ;
2023-03-03 11:55:06 +01:00
/ * *
* 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
* /
2021-09-29 18:17:34 +02:00
maxConnections : number ;
connections : number ;
2023-03-03 11:55:06 +01:00
/ * *
* Indicates whether or not the server is listening for connections .
* @since v5 . 7.0
* /
2021-09-29 18:17:34 +02:00
listening : boolean ;
/ * *
* events . EventEmitter
* 1 . close
* 2 . connection
* 3 . error
* 4 . listening
* /
addListener ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
addListener ( event : 'close' , listener : ( ) = > void ) : this ;
addListener ( event : 'connection' , listener : ( socket : Socket ) = > void ) : this ;
addListener ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
addListener ( event : 'listening' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
emit ( event : string | symbol , . . . args : any [ ] ) : boolean ;
2023-03-03 11:55:06 +01:00
emit ( event : 'close' ) : boolean ;
emit ( event : 'connection' , socket : Socket ) : boolean ;
emit ( event : 'error' , err : Error ) : boolean ;
emit ( event : 'listening' ) : boolean ;
2021-09-29 18:17:34 +02:00
on ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
on ( event : 'close' , listener : ( ) = > void ) : this ;
on ( event : 'connection' , listener : ( socket : Socket ) = > void ) : this ;
on ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
on ( event : 'listening' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
once ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
once ( event : 'close' , listener : ( ) = > void ) : this ;
once ( event : 'connection' , listener : ( socket : Socket ) = > void ) : this ;
once ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
once ( event : 'listening' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
prependListener ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
prependListener ( event : 'close' , listener : ( ) = > void ) : this ;
prependListener ( event : 'connection' , listener : ( socket : Socket ) = > void ) : this ;
prependListener ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
prependListener ( event : 'listening' , listener : ( ) = > void ) : this ;
2021-09-29 18:17:34 +02:00
prependOnceListener ( event : string , listener : ( . . . args : any [ ] ) = > void ) : this ;
2023-03-03 11:55:06 +01:00
prependOnceListener ( event : 'close' , listener : ( ) = > void ) : this ;
prependOnceListener ( event : 'connection' , listener : ( socket : Socket ) = > void ) : this ;
prependOnceListener ( event : 'error' , listener : ( err : Error ) = > void ) : this ;
prependOnceListener ( event : 'listening' , listener : ( ) = > void ) : this ;
}
type IPVersion = 'ipv4' | 'ipv6' ;
/ * *
* The ` BlockList ` object can be used with some network APIs to specify rules for
* disabling inbound or outbound access to specific IP addresses , IP ranges , or
* IP subnets .
* @since v15 . 0.0
* /
class BlockList {
/ * *
* Adds a rule to block the given IP address .
* @since v15 . 0.0
* @param address An IPv4 or IPv6 address .
* @param [ type = 'ipv4' ] Either ` 'ipv4' ` or ` 'ipv6' ` .
* /
addAddress ( address : string , type ? : IPVersion ) : void ;
addAddress ( address : SocketAddress ) : void ;
/ * *
* Adds a rule to block a range of IP addresses from ` start ` ( inclusive ) to ` end ` ( inclusive ) .
* @since v15 . 0.0
* @param start The starting IPv4 or IPv6 address in the range .
* @param end The ending IPv4 or IPv6 address in the range .
* @param [ type = 'ipv4' ] Either ` 'ipv4' ` or ` 'ipv6' ` .
* /
addRange ( start : string , end : string , type ? : IPVersion ) : void ;
addRange ( start : SocketAddress , end : SocketAddress ) : void ;
/ * *
* Adds a rule to block a range of IP addresses specified as a subnet mask .
* @since v15 . 0.0
* @param net The network IPv4 or IPv6 address .
* @param prefix The number of CIDR prefix bits . For IPv4 , this must be a value between ` 0 ` and ` 32 ` . For IPv6 , this must be between ` 0 ` and ` 128 ` .
* @param [ type = 'ipv4' ] Either ` 'ipv4' ` or ` 'ipv6' ` .
* /
addSubnet ( net : SocketAddress , prefix : number ) : void ;
addSubnet ( net : string , prefix : number , type ? : IPVersion ) : void ;
/ * *
* Returns ` true ` if the given IP address matches any of the rules added to the ` BlockList ` .
*
* ` ` ` js
* 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
* ` ` `
* @since v15 . 0.0
* @param address The IP address to check
* @param [ type = 'ipv4' ] Either ` 'ipv4' ` or ` 'ipv6' ` .
* /
check ( address : SocketAddress ) : boolean ;
check ( address : string , type ? : IPVersion ) : boolean ;
2021-09-29 18:17:34 +02:00
}
interface TcpNetConnectOpts extends TcpSocketConnectOpts , SocketConstructorOpts {
timeout? : number | undefined ;
}
interface IpcNetConnectOpts extends IpcSocketConnectOpts , SocketConstructorOpts {
timeout? : number | undefined ;
}
type NetConnectOpts = TcpNetConnectOpts | IpcNetConnectOpts ;
2023-03-03 11:55:06 +01:00
/ * *
* Creates a new TCP or ` IPC ` server .
*
* If ` allowHalfOpen ` is set to ` true ` , when the other end of the socket
* signals the end of transmission , the server will only send back the end of
* transmission when ` socket.end() ` is explicitly called . For example , in the
* context of TCP , when a FIN packed is received , a FIN packed is sent
* back only when ` socket.end() ` is explicitly called . Until then the
* connection is half - closed ( non - readable but still writable ) . See ` 'end' ` event and [ RFC 1122 ] ( https : //tools.ietf.org/html/rfc1122) (section 4.2.2.13) for more information.
*
* If ` pauseOnConnect ` is set to ` true ` , then the socket associated with each
* incoming connection will be paused , and no data will be read from its handle .
* This allows connections to be passed between processes without any data being
* read by the original process . To begin reading data from a paused socket , call ` socket.resume() ` .
*
* The server can be a TCP server or an ` IPC ` server , depending on what it ` listen() ` to .
*
* Here is an example of an TCP echo server which listens for connections
* on port 8124 :
*
* ` ` ` js
* const net = require ( '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' ) ;
* } ) ;
* ` ` `
*
* Test this by using ` telnet ` :
*
* ` ` ` console
* $ telnet localhost 8124
* ` ` `
*
* To listen on the socket ` /tmp/echo.sock ` :
*
* ` ` ` js
* server . listen ( '/tmp/echo.sock' , ( ) = > {
* console . log ( 'server bound' ) ;
* } ) ;
* ` ` `
*
* Use ` nc ` to connect to a Unix domain socket server :
*
* ` ` ` console
* $ nc - U / tmp / echo . sock
* ` ` `
* @since v0 . 5.0
* @param connectionListener Automatically set as a listener for the { @link 'connection' } event .
* /
2021-09-29 18:17:34 +02:00
function createServer ( connectionListener ? : ( socket : Socket ) = > void ) : Server ;
function createServer ( options? : ServerOpts , connectionListener ? : ( socket : Socket ) = > void ) : Server ;
2023-03-03 11:55:06 +01:00
/ * *
* Aliases to { @link createConnection } .
*
* Possible signatures :
*
* * { @link connect }
* * { @link connect } for ` IPC ` connections .
* * { @link connect } for TCP connections .
* /
2021-09-29 18:17:34 +02:00
function connect ( options : NetConnectOpts , connectionListener ? : ( ) = > void ) : Socket ;
function connect ( port : number , host? : string , connectionListener ? : ( ) = > void ) : Socket ;
function connect ( path : string , connectionListener ? : ( ) = > void ) : Socket ;
2023-03-03 11:55:06 +01:00
/ * *
* A factory function , which creates a new { @link 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 :
*
* * { @link createConnection }
* * { @link createConnection } for ` IPC ` connections .
* * { @link createConnection } for TCP connections .
*
* The { @link connect } function is an alias to this function .
* /
2021-09-29 18:17:34 +02:00
function createConnection ( options : NetConnectOpts , connectionListener ? : ( ) = > void ) : Socket ;
function createConnection ( port : number , host? : string , connectionListener ? : ( ) = > void ) : Socket ;
function createConnection ( path : string , connectionListener ? : ( ) = > void ) : Socket ;
2023-03-03 11:55:06 +01:00
/ * *
* Tests if input is an IP address . Returns ` 0 ` for invalid strings ,
* returns ` 4 ` for IP version 4 addresses , and returns ` 6 ` for IP version 6
* addresses .
* @since v0 . 3.0
* /
2021-09-29 18:17:34 +02:00
function isIP ( input : string ) : number ;
2023-03-03 11:55:06 +01:00
/ * *
* Returns ` true ` if input is a version 4 IP address , otherwise returns ` false ` .
* @since v0 . 3.0
* /
2021-09-29 18:17:34 +02:00
function isIPv4 ( input : string ) : boolean ;
2023-03-03 11:55:06 +01:00
/ * *
* Returns ` true ` if input is a version 6 IP address , otherwise returns ` false ` .
* @since v0 . 3.0
* /
2021-09-29 18:17:34 +02:00
function isIPv6 ( input : string ) : boolean ;
2023-03-03 11:55:06 +01:00
interface SocketAddressInitOptions {
/ * *
* The network address as either an IPv4 or IPv6 string .
* @default 127.0 . 0.1
* /
address? : string | undefined ;
/ * *
* @default ` 'ipv4' `
* /
family? : IPVersion | undefined ;
/ * *
* An IPv6 flow - label used only if ` family ` is ` 'ipv6' ` .
* @default 0
* /
flowlabel? : number | undefined ;
/ * *
* An IP port .
* @default 0
* /
port? : number | undefined ;
}
/ * *
* @since v15 . 14.0
* /
class SocketAddress {
constructor ( options : SocketAddressInitOptions ) ;
/ * *
* @since v15 . 14.0
* /
readonly address : string ;
/ * *
* Either \ ` 'ipv4' \` or \` 'ipv6' \` .
* @since v15 . 14.0
* /
readonly family : IPVersion ;
/ * *
* @since v15 . 14.0
* /
readonly port : number ;
/ * *
* @since v15 . 14.0
* /
readonly flowlabel : number ;
}
2021-09-29 18:17:34 +02:00
}
2022-04-10 02:18:16 +02:00
declare module 'node:net' {
export * from 'net' ;
}