Noderelay NPM | npm.io

Modules

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