noderelay

Modules

NodeRelay: A forwarder/redirector server inspired in WinRelay.
log
tracker

NodeRelay

A forwarder/redirector server inspired in WinRelay.

Author: Ivan Garavito ivangaravito@gmail.com

Introduction

This is an app that forwards/redirects data as-is to the servers defined. This helps you to:

Hide your real server address for security reasons.
Separate networks between clients and services.
Serve data from an isolated network by redirecting only the services you need.

Installation

All you need to get it with your is:

Install Node.js. Optionally, you can use node-install
Install NodeRelay with NPM:

ૐ » ~ λ npm install -g NodeRelay

or if you need root permissions:

ૐ » ~ λ sudo npm install -g NodeRelay

Quick Start

Let's say you have a fixed HTTP service at 127.0.0.1:3000, and you want to access using port 80. All you need to do is create the file config/local.json5 and write the following lines:

{
  localHost: '0.0.0.0',
  pool: [
    {
      localPort: 80
      rdirHost: '127.0.0.1',
      rdirPort: 3000
    }
  ]
}

After NodeRelay configuration is ready, simply run the app:

  $ cd /path/to/NodeRelay
  $ node .

Terminology

First of all, let's define the terminology used into this app.

service, is the server where you want to redirect.
local, is here, where NodeRelay is installed and redirecting.
client, is the host connecting to local and redirected to service.
localserver or server, is the server needed at local to get client connection and redirect it to service.

Configuration

Well documented, the default options are stored inside config/default.json5 file, and the user defined configuration is inside the config/local.json5 file, which can be reduced to something like the following:

{
  localHost: '127.0.0.1',
  pool: [
    {
      localPort: <localPort>,
      serverHost: '<serverHost>',
      serverPort: <serverPort>
    }
  ]
}

localHost defines the IP address where NodeRelay is going to be listening to.

pool is the port list where is defined for each local port to which server to redirect to:

localPort is the port at the local host to listen to new connections.
serverHost is the server's address to redirect to.
serverPort is the port at the server to redirect to.

Dynamic Forwarding/Redirection

Let's say you have two servers within a LAN network isolated from your Internet connection. These servers have a HTTP service for UI purposes, then the UI connects to a fixed port 3000 (and you cannot change it) for polling data. How you can make NodeRelay connect dynamically to that fixed port at the proper server?

Well, it's as easy as defining a local port with no server connection params at the pool. Your local.json5 file should look like this:

{
  localHost: 'my_isp_assing_ip',
  pool: [
    {	//DEVICE 1
      localPort: 81,
      serverHost: '192.168.1.101',
      serverPort: 80
    },
    {	//DEVICE 2
      localPort: 82,
      serverHost: '192.168.1.102',
      serverPort: 80
    },
    {	//FIXED PORT FOR DYNAMIC FORWARDING/REDIRECTION
      localPort: 3000
    }
  ]
}

API

NodeRelay
- ~LocalServer ⇐ external:EventEmitter

NodeRelay~LocalServer ⇐ `external:EventEmitter`

Abstracts the local server that redirect connections from a client to a service

Kind: inner class of NodeRelay
Extends: external:EventEmitter
Emits: event:close, event:error, event:listening, event:client-close, event:client-connection, event:service-close, event:service-error, event:service-redirection, event:service-redirection-dynamic, event:service-redirection-fixed

~LocalServer ⇐ external:EventEmitter

new LocalServer(options)

Param	Type	Description
options	`Object`	local and service options

localServer.close()

Stop local server from accepting new connections

Kind: instance method of LocalServer

localServer._connectService(clientSocket, options)

Connect to service and make client-service redirection

Kind: instance method of LocalServer

Param	Type	Description
clientSocket	`Socket`	Client socket
options	`Object`	Connection options to service
options.host	`string`	Address where is the service
options.port	`string`	TCP port at options.host where is the service

localServer.getDynamicServiceHost(Client) ⇒ `string`

Initializes the LocalServer instance

Kind: instance method of LocalServer
Returns: string - Service address when this is a local server for a dynamic redirection
Throws:

UserError The app instancing this class must override this method

Param	Type	Description
Client	`string`	IP address

localServer.init(options)

Initializes the LocalServer instance

Kind: instance method of LocalServer

Param	Type	Default	Description
options	`Object`		local and service options
[options.localHost]	`string`	`"localhost"`	IP address to listen to at local
options.localPort	`string`		TCP port to listen to at localHost
[options.serviceHost]	`string`	`"options.localHost"`	Address where is the service
[options.servicePort]	`string`	`"options.localPort"`	TCP port at serviceHost where is the service
[options.listenRetryTimes]	`number`	`1`	Retry times to get the local server up
[options.listenRetryTimeout]	`number`	`500`	Time in milliseconds to wait before next listen try
[options.connRetryTimes]	`number`	`1`	Retry times to connect to service
[options.connRetryTimeout]	`number`	`500`	Time in milliseconds to wait before next connection try

localServer._onConnection(client)

Client connection handler

Kind: instance method of LocalServer

Param	Type	Description
client	`Socket`	Client connection socket

localServer.start()

Start local server listening

Kind: instance method of LocalServer