Pinsave/counterstrike
1
1/**2 * The `node:dgram` module provides an implementation of UDP datagram sockets.3 *4 * ```js5 * import dgram from 'node:dgram';6 *7 * const server = dgram.createSocket('udp4');8 *9 * server.on('error', (err) => {10 * console.error(`server error:\n${err.stack}`);11 * server.close();12 * });13 *14 * server.on('message', (msg, rinfo) => {15 * console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);16 * });17 *18 * server.on('listening', () => {19 * const address = server.address();20 * console.log(`server listening ${address.address}:${address.port}`);21 * });22 *23 * server.bind(41234);24 * // Prints: server listening 0.0.0.0:4123425 * ```26 * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/dgram.js)27 */28declare module "dgram" {29 import { AddressInfo, BlockList } from "node:net";30 import * as dns from "node:dns";31 import { Abortable, EventEmitter } from "node:events";32 interface RemoteInfo {33 address: string;34 family: "IPv4" | "IPv6";35 port: number;36 size: number;37 }38 interface BindOptions {39 port?: number | undefined;40 address?: string | undefined;41 exclusive?: boolean | undefined;42 fd?: number | undefined;43 }44 type SocketType = "udp4" | "udp6";45 interface SocketOptions extends Abortable {46 type: SocketType;47 reuseAddr?: boolean | undefined;48 reusePort?: boolean | undefined;49 /**50 * @default false51 */52 ipv6Only?: boolean | undefined;53 recvBufferSize?: number | undefined;54 sendBufferSize?: number | undefined;55 lookup?:56 | ((57 hostname: string,58 options: dns.LookupOneOptions,59 callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,60 ) => void)61 | undefined;62 receiveBlockList?: BlockList | undefined;63 sendBlockList?: BlockList | undefined;64 }65 /**66 * Creates a `dgram.Socket` object. Once the socket is created, calling `socket.bind()` will instruct the socket to begin listening for datagram67 * messages. When `address` and `port` are not passed to `socket.bind()` the68 * method will bind the socket to the "all interfaces" address on a random port69 * (it does the right thing for both `udp4` and `udp6` sockets). The bound address70 * and port can be retrieved using `socket.address().address` and `socket.address().port`.71 *72 * If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.close()` on the socket:73 *74 * ```js75 * const controller = new AbortController();76 * const { signal } = controller;77 * const server = dgram.createSocket({ type: 'udp4', signal });78 * server.on('message', (msg, rinfo) => {79 * console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);80 * });81 * // Later, when you want to close the server.82 * controller.abort();83 * ```84 * @since v0.11.1385 * @param options Available options are:86 * @param callback Attached as a listener for `'message'` events. Optional.87 */88 function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;89 function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;90 /**91 * Encapsulates the datagram functionality.92 *93 * New instances of `dgram.Socket` are created using {@link createSocket}.94 * The `new` keyword is not to be used to create `dgram.Socket` instances.95 * @since v0.1.9996 */97 class Socket extends EventEmitter {98 /**99 * Tells the kernel to join a multicast group at the given `multicastAddress` and `multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the `multicastInterface` argument is not100 * specified, the operating system will choose101 * one interface and will add membership to it. To add membership to every102 * available interface, call `addMembership` multiple times, once per interface.103 *104 * When called on an unbound socket, this method will implicitly bind to a random105 * port, listening on all interfaces.106 *107 * When sharing a UDP socket across multiple `cluster` workers, the`socket.addMembership()` function must be called only once or an`EADDRINUSE` error will occur:108 *109 * ```js110 * import cluster from 'node:cluster';111 * import dgram from 'node:dgram';112 *113 * if (cluster.isPrimary) {114 * cluster.fork(); // Works ok.115 * cluster.fork(); // Fails with EADDRINUSE.116 * } else {117 * const s = dgram.createSocket('udp4');118 * s.bind(1234, () => {119 * s.addMembership('224.0.0.114');120 * });121 * }122 * ```123 * @since v0.6.9124 */125 addMembership(multicastAddress: string, multicastInterface?: string): void;126 /**127 * Returns an object containing the address information for a socket.128 * For UDP sockets, this object will contain `address`, `family`, and `port` properties.129 *130 * This method throws `EBADF` if called on an unbound socket.131 * @since v0.1.99132 */133 address(): AddressInfo;134 /**135 * For UDP sockets, causes the `dgram.Socket` to listen for datagram136 * messages on a named `port` and optional `address`. If `port` is not137 * specified or is `0`, the operating system will attempt to bind to a138 * random port. If `address` is not specified, the operating system will139 * attempt to listen on all addresses. Once binding is complete, a `'listening'` event is emitted and the optional `callback` function is140 * called.141 *142 * Specifying both a `'listening'` event listener and passing a `callback` to the `socket.bind()` method is not harmful but not very143 * useful.144 *145 * A bound datagram socket keeps the Node.js process running to receive146 * datagram messages.147 *148 * If binding fails, an `'error'` event is generated. In rare case (e.g.149 * attempting to bind with a closed socket), an `Error` may be thrown.150 *151 * Example of a UDP server listening on port 41234:152 *153 * ```js154 * import dgram from 'node:dgram';155 *156 * const server = dgram.createSocket('udp4');157 *158 * server.on('error', (err) => {159 * console.error(`server error:\n${err.stack}`);160 * server.close();161 * });162 *163 * server.on('message', (msg, rinfo) => {164 * console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);165 * });166 *167 * server.on('listening', () => {168 * const address = server.address();169 * console.log(`server listening ${address.address}:${address.port}`);170 * });171 *172 * server.bind(41234);173 * // Prints: server listening 0.0.0.0:41234174 * ```175 * @since v0.1.99176 * @param callback with no parameters. Called when binding is complete.177 */178 bind(port?: number, address?: string, callback?: () => void): this;179 bind(port?: number, callback?: () => void): this;180 bind(callback?: () => void): this;181 bind(options: BindOptions, callback?: () => void): this;182 /**183 * Close the underlying socket and stop listening for data on it. If a callback is184 * provided, it is added as a listener for the `'close'` event.185 * @since v0.1.99186 * @param callback Called when the socket has been closed.187 */188 close(callback?: () => void): this;189 /**190 * Associates the `dgram.Socket` to a remote address and port. Every191 * message sent by this handle is automatically sent to that destination. Also,192 * the socket will only receive messages from that remote peer.193 * Trying to call `connect()` on an already connected socket will result194 * in an `ERR_SOCKET_DGRAM_IS_CONNECTED` exception. If `address` is not195 * provided, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for `udp6` sockets)196 * will be used by default. Once the connection is complete, a `'connect'` event197 * is emitted and the optional `callback` function is called. In case of failure,198 * the `callback` is called or, failing this, an `'error'` event is emitted.199 * @since v12.0.0200 * @param callback Called when the connection is completed or on error.201 */202 connect(port: number, address?: string, callback?: () => void): void;203 connect(port: number, callback: () => void): void;204 /**205 * A synchronous function that disassociates a connected `dgram.Socket` from206 * its remote address. Trying to call `disconnect()` on an unbound or already207 * disconnected socket will result in an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception.208 * @since v12.0.0209 */210 disconnect(): void;211 /**212 * Instructs the kernel to leave a multicast group at `multicastAddress` using the `IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the213 * kernel when the socket is closed or the process terminates, so most apps will214 * never have reason to call this.215 *216 * If `multicastInterface` is not specified, the operating system will attempt to217 * drop membership on all valid interfaces.218 * @since v0.6.9219 */220 dropMembership(multicastAddress: string, multicastInterface?: string): void;221 /**222 * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.223 * @since v8.7.0224 * @return the `SO_RCVBUF` socket receive buffer size in bytes.225 */226 getRecvBufferSize(): number;227 /**228 * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.229 * @since v8.7.0230 * @return the `SO_SNDBUF` socket send buffer size in bytes.231 */232 getSendBufferSize(): number;233 /**234 * @since v18.8.0, v16.19.0235 * @return Number of bytes queued for sending.236 */237 getSendQueueSize(): number;238 /**239 * @since v18.8.0, v16.19.0240 * @return Number of send requests currently in the queue awaiting to be processed.241 */242 getSendQueueCount(): number;243 /**244 * By default, binding a socket will cause it to block the Node.js process from245 * exiting as long as the socket is open. The `socket.unref()` method can be used246 * to exclude the socket from the reference counting that keeps the Node.js247 * process active. The `socket.ref()` method adds the socket back to the reference248 * counting and restores the default behavior.249 *250 * Calling `socket.ref()` multiples times will have no additional effect.251 *252 * The `socket.ref()` method returns a reference to the socket so calls can be253 * chained.254 * @since v0.9.1255 */256 ref(): this;257 /**258 * Returns an object containing the `address`, `family`, and `port` of the remote259 * endpoint. This method throws an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception260 * if the socket is not connected.261 * @since v12.0.0262 */263 remoteAddress(): AddressInfo;264 /**265 * Broadcasts a datagram on the socket.266 * For connectionless sockets, the destination `port` and `address` must be267 * specified. Connected sockets, on the other hand, will use their associated268 * remote endpoint, so the `port` and `address` arguments must not be set.269 *270 * The `msg` argument contains the message to be sent.271 * Depending on its type, different behavior can apply. If `msg` is a `Buffer`,272 * any `TypedArray` or a `DataView`,273 * the `offset` and `length` specify the offset within the `Buffer` where the274 * message begins and the number of bytes in the message, respectively.275 * If `msg` is a `String`, then it is automatically converted to a `Buffer` with `'utf8'` encoding. With messages that276 * contain multi-byte characters, `offset` and `length` will be calculated with277 * respect to `byte length` and not the character position.278 * If `msg` is an array, `offset` and `length` must not be specified.279 *280 * The `address` argument is a string. If the value of `address` is a host name,281 * DNS will be used to resolve the address of the host. If `address` is not282 * provided or otherwise nullish, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for `udp6` sockets) will be used by default.283 *284 * If the socket has not been previously bound with a call to `bind`, the socket285 * is assigned a random port number and is bound to the "all interfaces" address286 * (`'0.0.0.0'` for `udp4` sockets, `'::0'` for `udp6` sockets.)287 *288 * An optional `callback` function may be specified to as a way of reporting289 * DNS errors or for determining when it is safe to reuse the `buf` object.290 * DNS lookups delay the time to send for at least one tick of the291 * Node.js event loop.292 *293 * The only way to know for sure that the datagram has been sent is by using a `callback`. If an error occurs and a `callback` is given, the error will be294 * passed as the first argument to the `callback`. If a `callback` is not given,295 * the error is emitted as an `'error'` event on the `socket` object.296 *297 * Offset and length are optional but both _must_ be set if either are used.298 * They are supported only when the first argument is a `Buffer`, a `TypedArray`,299 * or a `DataView`.300 *301 * This method throws `ERR_SOCKET_BAD_PORT` if called on an unbound socket.302 *303 * Example of sending a UDP packet to a port on `localhost`;304 *305 * ```js306 * import dgram from 'node:dgram';307 * import { Buffer } from 'node:buffer';308 *309 * const message = Buffer.from('Some bytes');310 * const client = dgram.createSocket('udp4');311 * client.send(message, 41234, 'localhost', (err) => {312 * client.close();313 * });314 * ```315 *316 * Example of sending a UDP packet composed of multiple buffers to a port on`127.0.0.1`;317 *318 * ```js319 * import dgram from 'node:dgram';320 * import { Buffer } from 'node:buffer';321 *322 * const buf1 = Buffer.from('Some ');323 * const buf2 = Buffer.from('bytes');324 * const client = dgram.createSocket('udp4');325 * client.send([buf1, buf2], 41234, (err) => {326 * client.close();327 * });328 * ```329 *330 * Sending multiple buffers might be faster or slower depending on the331 * application and operating system. Run benchmarks to332 * determine the optimal strategy on a case-by-case basis. Generally speaking,333 * however, sending multiple buffers is faster.334 *335 * Example of sending a UDP packet using a socket connected to a port on `localhost`:336 *337 * ```js338 * import dgram from 'node:dgram';339 * import { Buffer } from 'node:buffer';340 *341 * const message = Buffer.from('Some bytes');342 * const client = dgram.createSocket('udp4');343 * client.connect(41234, 'localhost', (err) => {344 * client.send(message, (err) => {345 * client.close();346 * });347 * });348 * ```349 * @since v0.1.99350 * @param msg Message to be sent.351 * @param offset Offset in the buffer where the message starts.352 * @param length Number of bytes in the message.353 * @param port Destination port.354 * @param address Destination host name or IP address.355 * @param callback Called when the message has been sent.356 */357 send(358 msg: string | NodeJS.ArrayBufferView | readonly any[],359 port?: number,360 address?: string,361 callback?: (error: Error | null, bytes: number) => void,362 ): void;363 send(364 msg: string | NodeJS.ArrayBufferView | readonly any[],365 port?: number,366 callback?: (error: Error | null, bytes: number) => void,367 ): void;368 send(369 msg: string | NodeJS.ArrayBufferView | readonly any[],370 callback?: (error: Error | null, bytes: number) => void,371 ): void;372 send(373 msg: string | NodeJS.ArrayBufferView,374 offset: number,375 length: number,376 port?: number,377 address?: string,378 callback?: (error: Error | null, bytes: number) => void,379 ): void;380 send(381 msg: string | NodeJS.ArrayBufferView,382 offset: number,383 length: number,384 port?: number,385 callback?: (error: Error | null, bytes: number) => void,386 ): void;387 send(388 msg: string | NodeJS.ArrayBufferView,389 offset: number,390 length: number,391 callback?: (error: Error | null, bytes: number) => void,392 ): void;393 /**394 * Sets or clears the `SO_BROADCAST` socket option. When set to `true`, UDP395 * packets may be sent to a local interface's broadcast address.396 *397 * This method throws `EBADF` if called on an unbound socket.398 * @since v0.6.9399 */400 setBroadcast(flag: boolean): void;401 /**402 * _All references to scope in this section are referring to [IPv6 Zone Indices](https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses), which are defined by [RFC403 * 4007](https://tools.ietf.org/html/rfc4007). In string form, an IP_404 * _with a scope index is written as `'IP%scope'` where scope is an interface name_405 * _or interface number._406 *407 * Sets the default outgoing multicast interface of the socket to a chosen408 * interface or back to system interface selection. The `multicastInterface` must409 * be a valid string representation of an IP from the socket's family.410 *411 * For IPv4 sockets, this should be the IP configured for the desired physical412 * interface. All packets sent to multicast on the socket will be sent on the413 * interface determined by the most recent successful use of this call.414 *415 * For IPv6 sockets, `multicastInterface` should include a scope to indicate the416 * interface as in the examples that follow. In IPv6, individual `send` calls can417 * also use explicit scope in addresses, so only packets sent to a multicast418 * address without specifying an explicit scope are affected by the most recent419 * successful use of this call.420 *421 * This method throws `EBADF` if called on an unbound socket.422 *423 * #### Example: IPv6 outgoing multicast interface424 *425 * On most systems, where scope format uses the interface name:426 *427 * ```js428 * const socket = dgram.createSocket('udp6');429 *430 * socket.bind(1234, () => {431 * socket.setMulticastInterface('::%eth1');432 * });433 * ```434 *435 * On Windows, where scope format uses an interface number:436 *437 * ```js438 * const socket = dgram.createSocket('udp6');439 *440 * socket.bind(1234, () => {441 * socket.setMulticastInterface('::%2');442 * });443 * ```444 *445 * #### Example: IPv4 outgoing multicast interface446 *447 * All systems use an IP of the host on the desired physical interface:448 *449 * ```js450 * const socket = dgram.createSocket('udp4');451 *452 * socket.bind(1234, () => {453 * socket.setMulticastInterface('10.0.0.2');454 * });455 * ```456 * @since v8.6.0457 */458 setMulticastInterface(multicastInterface: string): void;459 /**460 * Sets or clears the `IP_MULTICAST_LOOP` socket option. When set to `true`,461 * multicast packets will also be received on the local interface.462 *463 * This method throws `EBADF` if called on an unbound socket.464 * @since v0.3.8465 */466 setMulticastLoopback(flag: boolean): boolean;467 /**468 * Sets the `IP_MULTICAST_TTL` socket option. While TTL generally stands for469 * "Time to Live", in this context it specifies the number of IP hops that a470 * packet is allowed to travel through, specifically for multicast traffic. Each471 * router or gateway that forwards a packet decrements the TTL. If the TTL is472 * decremented to 0 by a router, it will not be forwarded.473 *474 * The `ttl` argument may be between 0 and 255\. The default on most systems is `1`.475 *476 * This method throws `EBADF` if called on an unbound socket.477 * @since v0.3.8478 */479 setMulticastTTL(ttl: number): number;480 /**481 * Sets the `SO_RCVBUF` socket option. Sets the maximum socket receive buffer482 * in bytes.483 *484 * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.485 * @since v8.7.0486 */487 setRecvBufferSize(size: number): void;488 /**489 * Sets the `SO_SNDBUF` socket option. Sets the maximum socket send buffer490 * in bytes.491 *492 * This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.493 * @since v8.7.0494 */495 setSendBufferSize(size: number): void;496 /**497 * Sets the `IP_TTL` socket option. While TTL generally stands for "Time to Live",498 * in this context it specifies the number of IP hops that a packet is allowed to499 * travel through. Each router or gateway that forwards a packet decrements the500 * TTL. If the TTL is decremented to 0 by a router, it will not be forwarded.501 * Changing TTL values is typically done for network probes or when multicasting.502 *503 * The `ttl` argument may be between 1 and 255\. The default on most systems504 * is 64.505 *506 * This method throws `EBADF` if called on an unbound socket.507 * @since v0.1.101508 */509 setTTL(ttl: number): number;510 /**511 * By default, binding a socket will cause it to block the Node.js process from512 * exiting as long as the socket is open. The `socket.unref()` method can be used513 * to exclude the socket from the reference counting that keeps the Node.js514 * process active, allowing the process to exit even if the socket is still515 * listening.516 *517 * Calling `socket.unref()` multiple times will have no additional effect.518 *519 * The `socket.unref()` method returns a reference to the socket so calls can be520 * chained.521 * @since v0.9.1522 */523 unref(): this;524 /**525 * Tells the kernel to join a source-specific multicast channel at the given `sourceAddress` and `groupAddress`, using the `multicastInterface` with the `IP_ADD_SOURCE_MEMBERSHIP` socket526 * option. If the `multicastInterface` argument527 * is not specified, the operating system will choose one interface and will add528 * membership to it. To add membership to every available interface, call `socket.addSourceSpecificMembership()` multiple times, once per interface.529 *530 * When called on an unbound socket, this method will implicitly bind to a random531 * port, listening on all interfaces.532 * @since v13.1.0, v12.16.0533 */534 addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;535 /**536 * Instructs the kernel to leave a source-specific multicast channel at the given `sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP` socket option. This method is537 * automatically called by the kernel when the538 * socket is closed or the process terminates, so most apps will never have539 * reason to call this.540 *541 * If `multicastInterface` is not specified, the operating system will attempt to542 * drop membership on all valid interfaces.543 * @since v13.1.0, v12.16.0544 */545 dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;546 /**547 * events.EventEmitter548 * 1. close549 * 2. connect550 * 3. error551 * 4. listening552 * 5. message553 */554 addListener(event: string, listener: (...args: any[]) => void): this;555 addListener(event: "close", listener: () => void): this;556 addListener(event: "connect", listener: () => void): this;557 addListener(event: "error", listener: (err: Error) => void): this;558 addListener(event: "listening", listener: () => void): this;559 addListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;560 emit(event: string | symbol, ...args: any[]): boolean;561 emit(event: "close"): boolean;562 emit(event: "connect"): boolean;563 emit(event: "error", err: Error): boolean;564 emit(event: "listening"): boolean;565 emit(event: "message", msg: Buffer, rinfo: RemoteInfo): boolean;566 on(event: string, listener: (...args: any[]) => void): this;567 on(event: "close", listener: () => void): this;568 on(event: "connect", listener: () => void): this;569 on(event: "error", listener: (err: Error) => void): this;570 on(event: "listening", listener: () => void): this;571 on(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;572 once(event: string, listener: (...args: any[]) => void): this;573 once(event: "close", listener: () => void): this;574 once(event: "connect", listener: () => void): this;575 once(event: "error", listener: (err: Error) => void): this;576 once(event: "listening", listener: () => void): this;577 once(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;578 prependListener(event: string, listener: (...args: any[]) => void): this;579 prependListener(event: "close", listener: () => void): this;580 prependListener(event: "connect", listener: () => void): this;581 prependListener(event: "error", listener: (err: Error) => void): this;582 prependListener(event: "listening", listener: () => void): this;583 prependListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;584 prependOnceListener(event: string, listener: (...args: any[]) => void): this;585 prependOnceListener(event: "close", listener: () => void): this;586 prependOnceListener(event: "connect", listener: () => void): this;587 prependOnceListener(event: "error", listener: (err: Error) => void): this;588 prependOnceListener(event: "listening", listener: () => void): this;589 prependOnceListener(event: "message", listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;590 /**591 * Calls `socket.close()` and returns a promise that fulfills when the socket has closed.592 * @since v20.5.0593 */594 [Symbol.asyncDispose](): Promise<void>;595 }596}597declare module "node:dgram" {598 export * from "dgram";599}600