telnetlib

A simple Node.js telnet server/client library. It provides an interface similar to the standard net module (viz. createServer and createConnection) while abstracting option negotiation and providing handlers for some common options.

Simple Example

This example is a server that, once option negotiation finishes, says hello world to the client and then echos anything it receives back to the client. The client portion simply echos anything back to the server.

Server

1const telnetlib = require('telnetlib');
2
3const server = telnetlib.createServer({}, (c) => {
4  c.on('negotiated', () => {
5    c.write('Hello World!');
6  });
7
8  c.on('data', (data) => {
9    c.write(data);
10  });
11});
12
13server.listen(9001);

Client

1const telnetlib = require('telnetlib');
2
3const client = telnetlib.createConnection(
4  {
5    host: '127.0.0.1',
6    port: 9001
7  },
8  () => {
9    client.on('data', (data) => {
10      client.write(data);
11    });
12  }
13);

Features

• RFC1143 option negotiation
• Telnet option handlers for:
  • SGA
  • NAWS
  • GMCP
  • MCCP2

Reference

telnetlib.createServer(options, handler)

• options Object
  • remoteOptions Array Option codes we want enabled remotely
  • localOptions Array Option codes we want enabled locally
  • receiveBuffermax integer How large the receive buffer is
  • subnegotiationBufferMax integer How large the subnegotiation buffer is
• handler Function listener for the connection event.

Creates a new telnet server.

telnetlib.createConnection(options, handler)

• options Object
  • host String Host the socket should connect to
  • port Integer Port the socket should connect to
  • remoteOptions Array Option codes we want enabled remotely
  • localOptions Array Option codes we want enabled locally
  • receiveBuffermax integer How large the receive buffer is
  • subnegotiationBufferMax integer How large the subnegotiation buffer is
• handler Function listener for the connect event.

A factory function which creates a net.Socket, wraps it in a TelnetSocket, initiates option negotiation, and returns the TelnetSocket.

telnetlib.defineOption(name, code[, handler])

• name String The name of the telnet option.
• code Integer The telnet option code
• handler TelnetOption Optional class that manages option

Register an option handler with the library.

Class: telnetlib.TelnetSocket

• Extends: Stream.Stream

This class wraps a socket and manages object negotiation.

new telnetlib.TelnetSocket(socket[, options])

• socket net.Socket Socket object to wrap
• options Object
  • remoteOptions Array Option codes we want enabled remotely
  • localOptions Array Option codes we want enabled locally
  • receiveBuffermax integer How large the receive buffer is
  • subnegotiationBufferMax integer How large the subnegotiation buffer is

Event: negotiated

Emitted when all option negotiations have been settled either through (dis)agreement or timeout.

Event: enable

• optionCode integer telnet option code
• at String value indicating where the option was enabled. Either 'LOCAL' or 'REMOTE'

Emitted when an option is enabled.

Event: disable

• optionCode integer telnet option code
• at String value indicating where the option was disabled. Either 'LOCAL' or 'REMOTE'

Emitted when an option is disabled.

TelnetSocket.enableRemote(option[, timeout])

• option - integer telnet option code
• timeout - integer timeout in milliseconds
• Returns: Promise

Request that an option be enabled remotely.

TelnetSocket.disableRemote(option[, timeout])

• option - integer telnet option code
• timeout - integer timeout in milliseconds
• Returns: Promise

Request that an option be disabled remotely.

TelnetSocket.enableLocal(option[, timeout])

• option - integer telnet option code
• timeout - integer timeout in milliseconds
• Returns: Promise

Request that an option be enabled locally.

TelnetSocket.disableLocal(option[, timeout])

• option - integer telnet option code
• timeout - integer timeout in milliseconds
• Returns: Promise

Request that an option be disabled locally.

TelnetSocket.getOption(code)

• code - integer telnet option code
• Returns: TelnetOption

Get the handler for the specified option.

Class: telnetlib.TelnetOption

This is the base class for option handlers.

enabled(at)

• at String value indicating where option was enabled. Either 'LOCAL' or 'REMOTE'

Called whenever the option is enabled. Intended to be overridden by subclasses.

disabled(at)

• at String value indicating where option was disabled. Either 'LOCAL' or 'REMOTE'

Called whenever the option is disabled. Intended to be overridden by subclasses.

subnegotiation(buffer)

• buffer Buffer contents of the subnegotiation

Called when a subnegotiation is received for an option. Intended to be overridden by subclasses.

Class: GMCP

• Extends: telnetlib.TelnetOption

This class handles sending and receiving GMCP message.

Event: gmcp

• packageName String the name of the package the message belongs to
• messageName String the name of the message
• data String | Number | Boolean | Object | Array The message data

Emitted when a GMCP message is received. packageName and messageName are normalized to lower case.

Event: gmcp/<name>

• data String | Number | Boolean | Object | Array The message data

As above, but instead of having packageName and messageName values they are included in the event name.

send(packageName, messageName[, data])

• packageName String the name of the package
• messageName String the name of the message
• data String | Number | Boolean | Object | Array The message data

Send a GMCP message.

Class: MCCP

• Extends: telnetlib.TelnetOption

This class handles MCCP2 compression.

endCompression([callback])

• callback Function optional callback

Only valid when MCCP is enabled locally. Sends a Z_FINISH flush and forces MCCP off locally.

Class: NAWS

• Extends: telnetlib.TelnetOption

This class handles sending and receiving window resize events.

Event: resize

• data Object
• width Integer The width reported by the client.
  • height Integer The height reported by the client.

Event emitted when a resize subnegotiation is received.

sendResize([width[, height]])

• width Integer The width to send. Default: 80
• height Integer The height to send. Default: 24

Send a resize subnegotiation.

Extending

The main reason to extend this library would be to add additional option handlers. This can be easily done by subclassing TelnetOption and registering it with the library using telnetlib.defineOption before creating a server or client. As in:

1const telnetlib = require('telnetlib');
2const { where } = telnetlib.constants;
3
4const ourOptionCode = 123;
5class Something extends telnetlib.TelnetOption {
6  constructor(socket, code) {
7    super(socket, ourOptionCode);
8  }
9
10  enabled(at) {
11    if (at == where.LOCAL) console.log('this option was enabled locally');
12  }
13
14  disabled(at) {
15    if (at == where.LOCAL) console.log('this option was disabled locally');
16  }
17
18  subnegotiation(buffer) {}
19}
20
21telnetlib.defineOption('Something', ourOptionCode, Something);

Advanced Examples

GMCP

This is similar to the simple example above, but instead of sending normal text back and forth across the connection, the same thing is done with GMCP messages.

Server

1const telnetlib = require('telnetlib');
2const { GMCP } = telnetlib.options;
3
4const server = telnetlib.createServer(
5  {
6    localOptions: [GMCP]
7  },
8  (c) => {
9    const gmcp = c.getOption(GMCP);
10    c.on('negotiated', () => {
11      gmcp.send('herp', 'derp', 42);
12    });
13
14    gmcp.on('gmcp/herp.derp', (data) => {
15      gmcp.send('herp', 'derp', data);
16    });
17  }
18);
19
20server.listen(9001);

Client

1const telnetlib = require('telnetlib');
2const { GMCP } = telnetlib.options;
3
4const client = telnetlib.createConnection(
5  {
6    host: '127.0.0.1',
7    port: 9001,
8    remoteOptions: [GMCP]
9  },
10  () => {
11    const gmcp = client.getOption(GMCP);
12    gmcp.on('gmcp/herp.derp', (data) => {
13      gmcp.send('herp', 'derp', data);
14    });
15  }
16);

Fancy Interfaces

Using the blessed library this example renders a box with in the middle of the terminal. The box will resize to fit in clients that support NAWS.

1const blessed = require('blessed');
2const telnetlib = require('telnetlib');
3const { ECHO, TRANSMIT_BINARY, NAWS, SGA } = telnetlib.options;
4
5const server = telnetlib.createServer(
6  {
7    remoteOptions: [NAWS, TRANSMIT_BINARY, SGA],
8    localOptions: [ECHO, TRANSMIT_BINARY, SGA]
9  },
10  (c) => {
11    let screen;
12
13    c.on('negotiated', () => {
14      screen = blessed.screen({
15        smartCSR: true,
16        input: c,
17        output: c,
18        height: 80,
19        width: 24,
20        terminal: 'xterm',
21        fullUnicode: true,
22        cursor: {
23          artificial: true,
24          shape: 'line',
25          blink: true,
26          color: null
27        }
28      });
29
30      const box = blessed.box({
31        parent: screen,
32        top: 'center',
33        left: 'center',
34        width: '50%',
35        height: '50%',
36        content: 'Hello World',
37        border: 'line'
38      });
39
40      screen.render();
41    });
42
43    c.on('end', () => {
44      if (screen) screen.destroy();
45    });
46  }
47);
48
49server.listen(9001);

License

MIT