We Keep Coding

Multiple Clients connected to the same Server using UDP in NodeJS

Is it possible to have multiple clients to the same UDP server ?
I'd like to broadcast the same data to all connected clients.
Here would be a starting sample, if it helps somehow ...
// Server
var news = [
"Borussia Dortmund wins German championship",
"Tornado warning for the Bay Area",
"More rain for the weekend"
];
var dgram = require('dgram');
var server = dgram.createSocket("udp4");
server.bind(function() {
server.setBroadcast(true)
server.setMulticastTTL(128);
setInterval(broadcastNew, 3000);
});
function broadcastNew() {
var message = new Buffer(news[Math.floor(Math.random() * news.length)]);
server.send(message, 0, message.length, 5007, "224.1.1.1");
console.log("Sent " + message + " to the wire...");
}
// Client 1
var PORT = 5007;
var dgram = require('dgram');
var client = dgram.createSocket('udp4');
client.on('listening', function() {
var address = client.address();
console.log('UDP Client listening on ' + address.address + ":" + address.port);
client.setBroadcast(true)
client.setMulticastTTL(128);
client.addMembership('224.1.1.1');
});
client.on('message', function(message, remote) {
console.log('A: Epic Command Received. Preparing Relay.');
console.log('B: From: ' + remote.address + ':' + remote.port + ' - ' + message);
});
client.bind(PORT);
// Client 2
// Here would go another client, it is possible ?

Yes, it is possible.
I won't go on a speech about how you should use TCP before UDP and only use UDP when absolutely necessary.
For your problem, the fact is that UDP doesn't have any "connection". You receive messages, you send messages, but there is no "connection".
So what you should do is:
When receiving a message from an incoming client, store the IP/Port used by the client
When wanting to send messages to clients, send to all the IP/Port combinations stored
Periodically remove old clients (for example who didn't send a message in the last 5 minutes)
You can detect when a message is received on a bound socket after the "message" event. Your code would look something like that (helped myself):
// Server
var news = [
"Borussia Dortmund wins German championship",
"Tornado warning for the Bay Area",
"More rain for the weekend"
];
var clients = {};
const dgram = require('dgram');
const server = dgram.createSocket('udp4');
server.on('error', (err) => {
console.log(`server error:\n${err.stack}`);
server.close();
});
server.on('message', (msg, rinfo) => {
console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
clients[JSON.stringify([rinfo.address, rinfo.port])] = true;
//use delete clients[client] to remove from the list of clients
});
function broadCastNew() {
var message = new Buffer(news[Math.floor(Math.random() * news.length)]);
for (var client in clients) {
client = JSON.parse(client);
var port = client[1];
var address = client[0];
server.send(message, 0, message.length, port, address);
}
console.log("Sent " + message + " to the wire...");
}
server.on('listening', () => {
var address = server.address();
console.log(`server listening ${address.address}:${address.port}`);
setInterval(broadcastNew, 3000);
});
server.bind(5007);
Now whenever your server gets an UDP message on port 5007, it will add the sender to the list of clients, and every 3 seconds it will send a message to all the clients stored. How to make the sender receive that piece of news is another story, but you can use a tool such as WireShark to confirm yourself that it was correctly sent back.
Here I didn't delete old clients but you probably should include a mechanism to store the last time they contacted you (instead of using = true you can for example store current time, then periodically remove old clients)
Broadcast and Multicast are probably different from what you imagine, broadcast is used for example to send a message to everyone on the local network.

NodeJS simple UDP client server application using broker

I am writing a simple client server NodeJS application using UDP protocol. The main point of this application is that it requires the use of a broker, whose function, in the given case, is to link the sender with the receiver. The requirements tell me that the sender doesn't need to be aware of the receiver's IP address and port number - it only needs to know the broker's corresponding IP and PORT. Afterwards, the broker will send the client's message to the server, based on the server's IP and PORT.
To clarify the previous(?confusing) paragraph, below you will find a illustration of what I've done so far:
sender.js
var PORT1 = XXXXX;
var HOST = '127.0.0.1';
var fs = require('fs');
var dgram = require('dgram');
var client = dgram.createSocket('udp4');
fs.readFile('Path/to/the/file','utf8', function (err, data) {
if (err) throw err;
var message = new Buffer(data);
client.send(data, 0, message.length, PORT1, HOST, function(err, bytes) {
if (err) throw err;
console.log('UDP message sent to ' + HOST +':'+ PORT1);
client.close();
});
});
The code above reads from a file, stores its contents in a buffer and sends it to the broker's port(the broker listens to the same port) and host(which, in my case is the localhost).
broker.js
var PORT1 = XXXXX;
var PORT2 = YYYYY;
var HOST = '127.0.0.1';
var dgram = require('dgram');
var server = dgram.createSocket('udp4');
var client = dgram.createSocket('udp4');
server.on('listening', function () {
var address = server.address();
console.log('UDP broker listening on ' + address.address + ":" + address.port);
});
server.on('message', function (message, remote) {
client.send(message, 0, message.length, PORT2, HOST, function(err, bytes) {
if (err) throw err;
console.log('UDP message sent to ' + HOST +':'+ PORT2);
client.close();
});
console.log(remote.address + ':' + remote.port +' - ' + message);
});
server.bind(PORT1, HOST);
Here, PORT1 is the port that the broker listens to(waiting for incoming messages from sender) and PORT2 is the port which transmits the message to the receiver(and correspondingly, the receiver listens to this port).
receiver.js
var PORT2 = YYYYY;
var HOST = '127.0.0.1';
var fs = require('fs');
var dgram = require('dgram');
var server = dgram.createSocket('udp4');
var parser = require('xml2json');
server.on('listening', function () {
var address = server.address();
console.log('UDP receiver listening on ' + address.address + ":" + address.port);
});
server.on('message', function (message, remote) {
console.log(remote.address + ':' + remote.port +' - ' + message);
var contents = fs.writeFile("/Path/To/Written/File", parser.toJson(message),
function(error){
if (error) {
console.log("error writing");
}
console.log("File was saved");
});
});
server.bind(PORT2, HOST);
The receiver gets the message from the broker and writes it to a file in the JSON format.
Here are the results:
Sender
UserName's-MacBook-Pro:UDP server UserName$ node sender.js
UDP message sent to 127.0.0.1:XXXXX
Broker
UserName's-MacBook-Pro:UDP server UserName$ node broker.js
UDP broker listening on 127.0.0.1:XXXXX
127.0.0.1:60009 - <?xml version="1.0"?>
<Some XML content here>
</XML content ends here>
UDP message sent to 127.0.0.1:YYYYY
Receiver
UserName's-MacBook-Pro:UDP server UserName$ node receiver.js
UDP receiver listening on 127.0.0.1:YYYYY
127.0.0.1:63407 - <?xml version="1.0"?>
<XML contents here>
</XML content ends here>
File was saved
I am sorry for the long post, but I want to specify all the details to eliminate(hopefully) any ambiguities. Now, to the matter,
HERE is my question
What changes should I make for the broker in order to solve the following problem:
In case of multiple senders and receivers, the broker should manage the ports to link the sender to the receiver(with any specified criteria).
Thank you in advance!

Take a look in this book "Node.js Design Patterns,Publisher:Packt Publishing By: Mario Casciaro ISBN: 978-1-78328-731-4 Year: 2014" at page 361. There is the exact thing you want to do with very good explanation.
Hope it will help!

emit() not working [Node.js]

I subscibe to laravel 5 event[channal] update.group and I recive message in console after I trigger event but on client side in browser I don't recive any message. Also after I trigger event I recive message in console and then node server stop working with message:
bash-4.2# node node.js
Listening on Port 3000
Message Recieved: testasdsa
/home/client/public_html/node_modules/ioredis/lib/parsers/javascript.js:216
throw err;
^
SyntaxError: Unexpected token e
at Object.parse (native)
at Redis.<anonymous> (/home/client/public_html/node_modules/node.js:10:20)
at Redis.emit (events.js:110:17)
at Redis.exports.returnReply (/home/client/public_html/node_modules/ioredis/lib/redis/parser.js:79:16)
at ReplyParser.<anonymous> (/home/client/public_html/node_modules/ioredis/lib/redis/parser.js:27:10)
at ReplyParser.emit (events.js:107:17)
at ReplyParser.send_reply (/home/client/public_html/node_modules/ioredis/lib/parsers/javascript.js:281:8)
at ReplyParser.execute (/home/client/public_html/node_modules/ioredis/lib/parsers/javascript.js:210:14)
at Socket.<anonymous> (/home/client/public_html/node_modules/ioredis/lib/redis/event_handler.js:90:22)
at Socket.emit (events.js:107:17)
at readableAddChunk (_stream_readable.js:163:16)
at Socket.Readable.push (_stream_readable.js:126:10)
at TCP.onread (net.js:538:20)
Here is my node.js file:
var app = require('express')();
var http = require('http').Server(app);
var io = require('socket.io')(http);
var Redis = require('ioredis');
var redis = new Redis();
redis.subscribe('update.group', function(err, count) {
});
redis.on('message', function(channel, message) {
console.log('Message Recieved: ' + message);
message = JSON.parse(message);
io.sockets.emit(channel + ':' + message.event, message.data);
});
http.listen(3000, function(){
console.log('Listening on Port 3000');
});
And for client side:
var socket = io.connect('127.0.0.1:3000');
socket.on("update.group", function(message){
// increase the power everytime we load test route
console.log(message);
});
Anyone can find what is problem?

It's pretty obvious from your debug output: testasdsa is not valid JSON, so you cannot parse it as such. You will need to change the code that publishes the messages so that it's properly JSON encoded.
Since it looks like you're expecting event and data properties on an object, the publisher would need to be writing something like { "event": "foo", "data": "testasdsa" }.
To fix the problem of browser clients not getting the events, you need to change this in your server script:
io.sockets.emit(channel + ':' + message.event, message.data);
to:
io.sockets.emit(message.event, message.data);
Then just make sure the publisher sends out something like { "event": "update.group", "data": "somedata" }

How to bind socket to more than one port, NodeJS

I have set up a node application which receives packets from a Port at an IP address and serves the contents to a web-page. This IP address has traffic going through two ports, 9999 and 10000. My application has the following code:
var PORT_ONE = 9999;
var PORT_TWO = 10000;
var SENSOR = '239.0.0.1';
var client = require('dgram').createSocket('udp4');
var dns = require('dns');
/* Client starts listening on IP */
client.on('listening', function () {
console.log('UDP Client listening on ' + SENSOR + ":" + PORT_TWO);
client.setMulticastTTL(1);
client.addMembership(SENSOR);
});
/* Client receives a message */
client.on('message', function (message, remote) {
var tempMessage = message.toString(); //cast Buffer var to String
var delimiter = "\n";
var tempData = tempMessage.split(delimiter);
console.log('From: ' + remote.address + ':' + remote.port +' - \n' + message);
var data = {
ip: [SENSOR],
info: [tempData]
};
sendMessage(data);
});
client.bind(PORT_ONE);
client.bind(PORT_TWO); //error here
When I run my node application in the terminal, I receive the error
dgram.js:163
throw new Error('Socket is already bound');
Where dgram.js is part of the Nodejs libraries. The error comes when binding to PORT_TWO. Is there a way to bind the socket to more than one port?

I want to add my 2 cents here, what I normally do is create array of ports and Ips and put in for loop binding on them one by one
udpclients = [5550,5551];
udpsockets=[]
var dgram = require('dgram');
udpclients.forEach(function(port){
var udpServer = dgram.createSocket('udp4');
udpServer.bind(port,'127.0.0.1')
udpServer.on('listening', function() {
var address = udpServer.address()
console.log("listening"+address.address+" port::"+address.port)
});
udpServer.on('message', function(msg, rinfo) {
console.log("message received :: "+ msg +" address::"+rinfo.address+ "port = "+ rinfo.port )
});
});

Or you can bind multiple sockets, wrap them into streams and then combine streams to get feeling of one single socket.

Send Broadcast datagram

I need to send a broadcast datagram to all machine (servers) connected to my network.
I'm using NodeJS Multicast
Client
var dgram = require('dgram');
var message = new Buffer("Some bytes");
var client = dgram.createSocket("udp4");
client.send(message, 0, message.length, 41234, "localhost");
// If I'm in the same machine 'localhost' works
// I need to do something 192.168.0.255 or 255.255.255
client.close();
Servers
var dgram = require("dgram");
var server = dgram.createSocket("udp4");
server.on("message", function (msg, rinfo) {
console.log("server got: " + msg + " from " +
rinfo.address + ":" + rinfo.port);
});
server.on("listening", function () {
var address = server.address();
console.log("server listening " + address.address + ":" + address.port);
});
server.bind(41234);
Thanks.

I spent a lot of time trying to be able to do UDP broadcasting and multicasting between computers. Hopefully this makes it easier for others since this topic is quite difficult to find answers for on the web. These solutions work in Node versions 6.x-12.x:
UDP Broadcasting
Calculate the broadcast address
Broadcast address = (~subnet mask) | (host's IP address) - see Wikipedia. Use ipconfig(Windows) or ifconfig(Linux), or checkout the netmask module.
Server (remember to change BROADCAST_ADDR to the correct broadcast address)
var PORT = 6024;
var BROADCAST_ADDR = "58.65.67.255";
var dgram = require('dgram');
var server = dgram.createSocket("udp4");
server.bind(function() {
server.setBroadcast(true);
setInterval(broadcastNew, 3000);
});
function broadcastNew() {
var message = Buffer.from("Broadcast message!");
server.send(message, 0, message.length, PORT, BROADCAST_ADDR, function() {
console.log("Sent '" + message + "'");
});
}
Client
var PORT = 6024;
var dgram = require('dgram');
var client = dgram.createSocket('udp4');
client.on('listening', function () {
var address = client.address();
console.log('UDP Client listening on ' + address.address + ":" + address.port);
client.setBroadcast(true);
});
client.on('message', function (message, rinfo) {
console.log('Message from: ' + rinfo.address + ':' + rinfo.port +' - ' + message);
});
client.bind(PORT);
UDP Multicasting
Multicast addresses
Looking at the IPv4 Multicast Address Space Registry and more in-depth clarification in the RFC 2365 manual section 6, we find the appropriate local scope multicast addresses are 239.255.0.0/16 and 239.192.0.0/14 (that is, unless you obtain permission to use other ones).
The multicast code below works just fine on Linux (and many other platforms) with these addresses.
Most operating systems send and listen for multicasts via specific interfaces, and by default they will often choose the wrong interface if multiple interfaces are available, so you never receive multicasts on another machine (you only receive them on localhost). Read more in the Node.js docs. For the code to work reliably, change the code so you specify the host's IP address for the interface you wish to use, as follows:
Server - server.bind(SRC_PORT, HOST_IP_ADDRESS, function() ...
Client - client.addMembership(MULTICAST_ADDR, HOST_IP_ADDRESS);
Take a look at these supporting sources: NodeJS, Java, C#, and a helpful command to see which multicast addresses you are subscribed to - netsh interface ipv4 show joins.
Server
var SRC_PORT = 6025;
var PORT = 6024;
var MULTICAST_ADDR = '239.255.255.250';
var dgram = require('dgram');
var server = dgram.createSocket("udp4");
server.bind(SRC_PORT, function () { // Add the HOST_IP_ADDRESS for reliability
setInterval(multicastNew, 4000);
});
function multicastNew() {
var message = Buffer.from("Multicast message!");
server.send(message, 0, message.length, PORT, MULTICAST_ADDR, function () {
console.log("Sent '" + message + "'");
});
}
Client
var PORT = 6024;
var MULTICAST_ADDR = '239.255.255.250';
var dgram = require('dgram');
var client = dgram.createSocket('udp4');
client.on('listening', function () {
var address = client.address();
console.log('UDP Client listening on ' + address.address + ":" + address.port);
});
client.on('message', function (message, rinfo) {
console.log('Message from: ' + rinfo.address + ':' + rinfo.port + ' - ' + message);
});
client.bind(PORT, function () {
client.addMembership(MULTICAST_ADDR); // Add the HOST_IP_ADDRESS for reliability
});
UPDATE: There are additional options for server.send (named socket.send in the docs). You can use a string for the msg instead of a Buffer, and depending on your version, several parameters are optional. You can also check whether an error has occurred in the callback function.
UPDATE: Since Node.js v6, new Buffer(str) is deprecated in favor of Buffer.from(str). The code above has been updated to reflect this change. If you are using an earlier version of Node, use the former syntax.

I never used Node.js, but I do recall that with Berkely sockets (which seem to be the most widely used implementation of sockets) you need to enable the SO_BROADCAST socket option to be able to send datagrams to the broadcast address. Looking up the dgram documentation, there seems to be a function for it.
var client = dgram.createSocket("udp4");
client.setBroadcast(true);
client.send(message, 0, message.length, 41234, "192.168.0.255");
You might want to find out the broadcast address programmatically, but I can't help you with that.

I think since node 0.10.0 some things has changed this works for me now:
//var broadcastAddress = "127.255.255.255";
var broadcastAddress = "192.168.0.255";
var message = new Buffer("Some bytes");
var client = dgram.createSocket("udp4");
client.bind();
client.on("listening", function () {
client.setBroadcast(true);
client.send(message, 0, message.length, 6623, broadcastAddress, function(err, bytes) {
client.close();
});
});
Hope this helps somebody ;)

If you want a AUTOMATIC BROADCAST ADDRESS yo can do:
const broadcastAddress = require('broadcast-address');
const os = require("os")
var PORT = 1234;
var dgram = require('dgram');
var server = dgram.createSocket("udp4");
server.bind(function() {
server.setBroadcast(true);
setInterval(broadcastNew, 5000);
});
function broadcastNew() {
var message = Buffer.from("Broadcast message!");
Object.keys(os.networkInterfaces()).forEach(it=>{
console.log(broadcastAddress(it));
server.send(message, 0, message.length, PORT, broadcastAddress(it), function() {
console.log("Sent '" + message + "'");
});
})
}
This code will get a broadcast address for each interface on you server and send a message.
;) reguards
NOTE: dont forget install broadcast-address = "npm i broadcast-address"