Socket
Socket
Sign inDemoInstall

node-ipc

Package Overview
Dependencies
Maintainers
9
Versions
79
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

node-ipc - npm Package Compare versions

Comparing version 8.1.1 to 8.8.0

local-node-ipc-certs/private/oldclient.key
local-node-ipc-certs/private/oldserver.key

51

dao/client.js

@@ -6,3 +6,3 @@ 'use strict';

eventParser = require('./eventParser.js'),
Pubsub = require('event-pubsub'),
Events = require('event-pubsub'),
Message = require('js-message'),

@@ -12,17 +12,20 @@ fs = require('fs'),

function init(config,log){
let client={
config : config,
queue : new Queue,
socket : false,
connect : connect,
emit : emit,
log : log,
retriesRemaining:config.maxRetries||0,
explicitlyDisconnected: false
};
new Pubsub(client);
return client;
class Client extends Events{
constructor(config,log){
super();
Object.assign(
this,
{
Client : Client,
config : config,
queue : new Queue,
socket : false,
connect : connect,
emit : emit,
log : log,
retriesRemaining:config.maxRetries||0,
explicitlyDisconnected: false
}
);
}
}

@@ -127,3 +130,3 @@

client.log('\n\n######\nerror: ', err);
client.trigger('error', err);
client.publish('error', err);

@@ -136,3 +139,3 @@ }

function connectionMade(){
client.trigger('connect');
client.publish('connect');
client.retriesRemaining=client.config.maxRetries;

@@ -156,3 +159,3 @@ client.log('retrying reset');

){
client.trigger('disconnect');
client.publish('disconnect');
client.log(

@@ -165,3 +168,3 @@ (client.config.id),

client.socket.destroy();
client.trigger('destroy');
client.publish('destroy');
client=undefined;

@@ -180,3 +183,3 @@

client.trigger('disconnect');
client.publish('disconnect');
}

@@ -190,3 +193,3 @@ );

if(client.config.rawBuffer){
client.trigger(
client.publish(
'data',

@@ -223,3 +226,3 @@ new Buffer(data,client.config.encoding)

client.log('detected event', message.type, message.data);
client.trigger(
client.publish(
message.type,

@@ -239,2 +242,2 @@ message.data

module.exports=init;
module.exports=Client;

537

dao/socketServer.js

@@ -8,5 +8,54 @@ 'use strict';

eventParser = require('./eventParser.js'),
Pubsub = require('event-pubsub'),
Events = require('event-pubsub'),
Message = require('js-message');
class Server extends Events{
constructor(path,config,log,port){
super();
Object.assign(
this,
{
config : config,
path : path,
port : port,
udp4 : false,
udp6 : false,
log : log,
server : false,
sockets : [],
emit : emit,
broadcast : broadcast
}
);
this.on(
'close',
serverClosed.bind(this)
);
}
onStart(socket){
this.trigger(
'start',
socket
);
}
stop(){
this.server.close();
}
start(){
if(!this.path){
this.log('Socket Server Path not specified, refusing to start');
return;
}
fs.unlink(
this.path,
startServer.bind(this)
);
}
}
function emit(socket, type, data){

@@ -67,310 +116,276 @@ this.log('dispatching event to socket', ' : ', type, data);

function init(path,config,log,port){
let server={
config : config,
path : path,
port : port,
udp4 : false,
udp6 : false,
log : log,
server : false,
sockets : [],
emit : emit,
broadcast : broadcast,
onStart : function onStart(socket){
this.trigger(
'start',
socket
);
},
stop:function stop(){
server.server.close();
},
start : function start(){
if(!this.path){
server.log('Socket Server Path not specified, refusing to start');
return;
function serverClosed(){
for(let i=0, count=this.sockets.length; i<count; i++){
let socket=this.sockets[i];
let destroyedSocketId=false;
if(socket){
if(socket.readable){
continue;
}
}
fs.unlink(
this.path,
function () {
server.log(
'starting server on ',server.path,
((server.port)?`:${server.port}`:'')
);
if(socket.id){
destroyedSocketId=socket.id;
}
if(!server.udp4 && !server.udp6){
if(!server.config.tls){
server.server=net.createServer(
serverCreated
);
}else{
server.log('starting TLS server',server.config.tls);
if(server.config.tls.private){
server.config.tls.key=fs.readFileSync(server.config.tls.private);
}else{
server.config.tls.key=fs.readFileSync(`${__dirname}/../local-node-ipc-certs/private/server.key`);
}
if(server.config.tls.public){
server.config.tls.cert=fs.readFileSync(server.config.tls.public);
}else{
server.config.tls.cert=fs.readFileSync(`${__dirname}/../local-node-ipc-certs/server.pub`);
}
if(server.config.tls.dhparam){
server.config.tls.dhparam=fs.readFileSync(server.config.tls.dhparam);
}
if(server.config.tls.trustedConnections){
if(typeof server.config.tls.trustedConnections === 'string'){
server.config.tls.trustedConnections=[server.config.tls.trustedConnections];
}
server.config.tls.ca=[];
for(let i=0; i<server.config.tls.trustedConnections.length; i++){
server.config.tls.ca.push(
fs.readFileSync(server.config.tls.trustedConnections[i])
);
}
}
server.server=tls.createServer(
server.config.tls,
serverCreated
);
}
}else{
function UDPWrite(message,socket){
let data=new Buffer(message, server.config.encoding);
server.server.send(
data,
0,
data.length,
socket.port,
socket.address,
function(err, bytes) {
if(err){
server.log('error writing data to socket',err);
server.trigger(
'error',
function(err){
server.trigger('error',err);
}
);
}
}
);
}
this.log('socket disconnected',destroyedSocketId.toString());
server.server=dgram.createSocket(
((server.udp4)? 'udp4':'udp6')
);
server.server.write=UDPWrite;
server.server.on(
'listening',
function () {
serverCreated(server.server);
}
);
}
if(socket && socket.destroy){
socket.destroy();
}
server.server.on(
'error',
function(err){
server.log('server error',err);
this.sockets.splice(i,1);
server.trigger(
'error',
err
);
}
);
this.publish('socket.disconnected', socket, destroyedSocketId);
server.server.maxConnections=server.config.maxConnections;
return;
}
}
function serverCreated(socket) {
server.sockets.push(socket);
function gotData(socket,data,UDPSocket){
let sock=((this.udp4 || this.udp6)? UDPSocket : socket);
if(this.config.rawBuffer){
data=new Buffer(data,this.config.encoding);
this.publish(
'data',
data,
sock
);
return;
}
if(socket.setEncoding){
socket.setEncoding(server.config.encoding);
}
if(!this.ipcBuffer){
this.ipcBuffer='';
}
server.log('## socket connection to server detected ##');
socket.on(
'close',
function(socket){
server.trigger(
'close',
socket
);
}
);
data=(this.ipcBuffer+=data);
socket.on(
'error',
function(err){
server.log('server socket error',err);
if(data.slice(-1)!=eventParser.delimiter || data.indexOf(eventParser.delimiter) == -1){
this.log('Messages are large, You may want to consider smaller messages.');
return;
}
server.trigger('error',err);
}
);
this.ipcBuffer='';
socket.on(
'data',
function(data,UDPSocket){
let sock=((server.udp4 || server.udp6)? UDPSocket : socket);
if(server.config.rawBuffer){
data=new Buffer(data,server.config.encoding);
server.trigger(
'data',
data,
sock
);
return;
}
data=eventParser.parse(data);
if(!this.ipcBuffer){
this.ipcBuffer='';
}
while(data.length>0){
let message=new Message;
message.load(data.shift());
data=(this.ipcBuffer+=data);
this.log('received event of : ',message.type,message.data);
if(data.slice(-1)!=eventParser.delimiter || data.indexOf(eventParser.delimiter) == -1){
server.log('Messages are large, You may want to consider smaller messages.');
return;
}
if(message.data.id){
sock.id=message.data.id;
}
this.ipcBuffer='';
this.publish(
message.type,
message.data,
sock
);
}
}
data=eventParser.parse(data);
function socketClosed(socket){
this.publish(
'close',
socket
);
}
while(data.length>0){
let message=new Message;
message.load(data.shift());
function serverCreated(socket) {
this.sockets.push(socket);
server.log('received event of : ',message.type,message.data);
if(socket.setEncoding){
socket.setEncoding(this.config.encoding);
}
if(message.data.id){
sock.id=message.data.id;
}
this.log('## socket connection to server detected ##');
socket.on(
'close',
socketClosed.bind(this)
);
server.trigger(
message.type,
message.data,
sock
);
}
}
);
socket.on(
'error',
function(err){
this.log('server socket error',err);
socket.on(
'message',
function(msg,rinfo) {
if (!rinfo){
return;
}
this.publish('error',err);
}.bind(this)
);
server.log('Received UDP message from ', rinfo.address, rinfo.port);
let data;
socket.on(
'data',
gotData.bind(this,socket)
);
if(server.config.rawSocket){
data=new Buffer(msg,server.config.encoding);
}else{
data=msg.toString();
}
socket.emit('data',data,rinfo);
}
);
socket.on(
'message',
function(msg,rinfo) {
if (!rinfo){
return;
}
server.trigger(
'connect',
socket
);
this.log('Received UDP message from ', rinfo.address, rinfo.port);
let data;
if(server.config.rawBuffer){
return;
}
}
if(this.config.rawSocket){
data=new Buffer(msg,this.config.encoding);
}else{
data=msg.toString();
}
socket.emit('data',data,rinfo);
}.bind(this)
);
function started(socket){
server.onStart(socket);
}
this.publish(
'connect',
socket
);
if(!port){
server.log('starting server as', 'Unix || Windows Socket');
if (process.platform ==='win32'){
server.path = server.path.replace(/^\//, '');
server.path = server.path.replace(/\//g, '-');
server.path= `\\\\.\\pipe\\${server.path}`;
}
if(this.config.rawBuffer){
return;
}
}
server.server.listen(
server.path,
started
);
function startServer() {
this.log(
'starting server on ',this.path,
((this.port)?`:${this.port}`:'')
);
return;
}
if(!this.udp4 && !this.udp6){
if(!this.config.tls){
this.log('starting TCP server',this.config.tls);
this.server=net.createServer(
serverCreated.bind(this)
);
}else{
startTLSServer.bind(this);
}
}else{
this.server=dgram.createSocket(
((this.udp4)? 'udp4':'udp6')
);
this.server.write=UDPWrite.bind(this);
this.server.on(
'listening',
function UDPServerStarted() {
serverCreated.bind(this)(this.server);
}.bind(this)
);
}
if(!server.udp4 && !server.udp6){
server.log('starting server as', (server.config.tls?'TLS':'TCP'));
server.server.listen(
server.port,
server.path,
started
);
return;
}
this.server.on(
'error',
function(err){
this.log('server error',err);
server.log('starting server as',((server.udp4)? 'udp4':'udp6'));
server.server.bind(
server.port,
server.path
);
started(
{
address : server.path,
port : server.port
}
);
}
this.publish(
'error',
err
);
}
};
);
new Pubsub(server);
this.server.maxConnections=this.config.maxConnections;
server.on(
'close',
function(){
for(let i=0, count=server.sockets.length; i<count; i++){
let socket=server.sockets[i];
let destroyedSocketId=false;
if(!this.port){
this.log('starting server as', 'Unix || Windows Socket');
if (process.platform ==='win32'){
this.path = this.path.replace(/^\//, '');
this.path = this.path.replace(/\//g, '-');
this.path= `\\\\.\\pipe\\${this.path}`;
}
if(socket){
if(socket.readable){
continue;
}
}
this.server.listen(
this.path,
this.onStart.bind(this)
);
if(socket.id){
destroyedSocketId=socket.id;
}
return;
}
server.log('socket disconnected',destroyedSocketId.toString());
if(!this.udp4 && !this.udp6){
this.log('starting server as', (this.config.tls?'TLS':'TCP'));
this.server.listen(
this.port,
this.path,
this.onStart.bind(this)
);
return;
}
if(socket && socket.destroy){
socket.destroy();
}
this.log('starting server as',((this.udp4)? 'udp4':'udp6'));
server.sockets.splice(i,1);
this.server.bind(
this.port,
this.path
);
server.trigger('socket.disconnected', socket, destroyedSocketId);
this.onStart(
{
address : this.path,
port : this.port
}
);
}
return;
function startTLSServer(){
this.log('starting TLS server',this.config.tls);
if(this.config.tls.private){
this.config.tls.key=fs.readFileSync(this.config.tls.private);
}else{
this.config.tls.key=fs.readFileSync(`${__dirname}/../local-node-ipc-certs/private/server.key`);
}
if(this.config.tls.public){
this.config.tls.cert=fs.readFileSync(this.config.tls.public);
}else{
this.config.tls.cert=fs.readFileSync(`${__dirname}/../local-node-ipc-certs/server.pub`);
}
if(this.config.tls.dhparam){
this.config.tls.dhparam=fs.readFileSync(this.config.tls.dhparam);
}
if(this.config.tls.trustedConnections){
if(typeof this.config.tls.trustedConnections === 'string'){
this.config.tls.trustedConnections=[this.config.tls.trustedConnections];
}
this.config.tls.ca=[];
for(let i=0; i<this.config.tls.trustedConnections.length; i++){
this.config.tls.ca.push(
fs.readFileSync(this.config.tls.trustedConnections[i])
);
}
}
this.server=tls.createServer(
this.config.tls,
serverCreated.bind(this)
);
}
function UDPWrite(message,socket){
let data=new Buffer(message, this.config.encoding);
this.server.send(
data,
0,
data.length,
socket.port,
socket.address,
function(err, bytes) {
if(err){
this.log('error writing data to socket',err);
this.publish(
'error',
function(err){
this.publish('error',err);
}
);
}
}
);
return server;
}
module.exports=init;
module.exports=Server;

3

example/TLSSocket/readme.md

@@ -9,2 +9,3 @@ # Using TLS and SSL for Secure node-ipc

- openssl req -new -x509 -key server.key -out server.pub -days 365 -config openssl.cnf
- openssl req -new -x509 -key client.key -out client.pub -days 365 -config openssl.cnf
- talk about openssl.cnf edits

@@ -16,3 +17,3 @@

#### talk about security
- keep private keys private, don't shared
- keep private keys private, don't share

@@ -19,0 +20,0 @@ #### talk about using hostname not ip for best security validation of certs

4

package.json
{
"name": "node-ipc",
"version": "8.1.1",
"version": "8.8.0",
"description": "A nodejs module for local and remote Inter Process Communication (IPC), Neural Networking, and able to facilitate machine learning.",

@@ -14,3 +14,3 @@ "main": "node-ipc.js",

"colors": "*",
"event-pubsub": ">=2.1.2",
"event-pubsub": ">=4.0.0",
"js-message": ">=1.0.5",

@@ -17,0 +17,0 @@ "js-queue": ">=1.0.0",

9

README.md

@@ -456,3 +456,4 @@ node-ipc

|connect||triggered when socket connected|
|disconnect||triggered when socket disconnected|
|disconnect||triggered by client when socket has disconnected from server|
|socket.disconnected|socket destroyedSocketID|triggered by server when a client socket has disconnected|
|destroy||triggered when socket has been totally destroyed, no further auto retries will happen and all references are gone.|

@@ -523,2 +524,8 @@ |data|buffer|triggered when ipc.config.rawBuffer is true and a message is received.|

);
ipc.server.on(
'socket.disconnected',
function(socket, destroyedSocketID) {
ipc.log('client ' + destroyedSocketID + ' has disconnected!');
}
);
}

@@ -525,0 +532,0 @@ );

local-node-ipc-certs/client.pub

Sorry, the diff of this file is not supported yet

local-node-ipc-certs/private/client.key

Sorry, the diff of this file is not supported yet

local-node-ipc-certs/private/server.key

Sorry, the diff of this file is not supported yet

local-node-ipc-certs/server.pub

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc