What is the Node.js equivalent of the fgetc() function in php? And how would I apply it to a socket?
I'm working on a node.js port of this php script: http://code.google.com/p/bf2php/source/browse/trunk/rcon/BF2RConBase.class.php
Basically it uses sockets to connect to Battlefield 2 based game servers. The function I'm looking at is:
protected function read($bare = false) {
$delim = $bare ? "
" : "\x04";
for($buffer = ''; ($char = fgetc($this->socket)) != $delim; $buffer .= $char);
return trim($buffer);
}
Its supposed to grab the first line directly from the socket (from what I gather) one character at a time up til the ' '. I'm assuming the output is used for grabbing an encryption salt. The function is called in the socket connect event as part of the code that generates the encrypted password needed to login. Can anyone show me what a Node.js equivalent of this function might look like?
The docs have an excellent example of how to connect to a server over the network.
var net = require('net');
var client = net.connect({port: 8124},
function() { //'connect' listener
console.log('client connected');
client.write('world!
');
});
client.on('data', function(data) {
console.log(data.toString());
client.end();
});
client.on('end', function() {
console.log('client disconnected');
});
Simply change the data event handler to buffer incoming data until you've recieved the information you want.
To do that, you'll want to know how to use a Buffer.
Here's a concrete example of how to buffer data from a stream and parse out messages delimited by a specific character. I notice in the linked PHP that the protocol you're trying to implement delimts messages with a EOT (0x04) character.
var net = require('net');
var max = 1024 * 1024 // 1 MB, the maximum amount of data that we will buffer (prevent a bad server from crashing us by filling up RAM)
, allocate = 4096; // how much memory to allocate at once, 4 kB (there's no point in wasting 1 MB of RAM to buffer a few bytes)
, buffer=new Buffer(allocate) // create a new buffer that allocates 4 kB to start
, nread=0 // how many bytes we've buffered so far
, nproc=0 // how many bytes in the buffer we've processed (to avoid looping over the entire buffer every time data is received)
, client = net.connect({host:'example.com', port: 8124}); // connect to the server
client.on('data', function(chunk) {
if (nread + chunk.length > buffer.length) { // if the buffer is too small to hold the data
var need = Math.min(chunk.length, allocate); // allocate at least 4kB
if (nread + need > max) throw new Error('Buffer overflow'); // uh-oh, we're all full - TODO you'll want to handle this more gracefully
var newbuf = new Buffer(buffer.length + need); // because Buffers can't be resized, we must allocate a new one
buffer.copy(newbuf); // and copy the old one's data to the new one
buffer = newbuf; // the old, small buffer will be garbage collected
}
chunk.copy(buffer, nread); // copy the received chunk of data into the buffer
nread += chunk.length; // add this chunk's length to the total number of bytes buffered
pump(); // look at the buffer to see if we've received enough data to act
});
client.on('end', function() {
// handle disconnect
});
client.on('error', function(err) {
// handle errors
});
function find(byte) { // look for a specific byte in the buffer
for (var i = nproc; i < nread; i++) { // look through the buffer, starting from where we left off last time
if (buffer.readUInt8(i, true) == byte) { // we've found one
return i;
}
}
}
function slice(bytes) { // discard bytes from the beginning of a buffer
buffer = buffer.slice(bytes); // slice off the bytes
nread -= bytes; // note that we've removed bytes
nproc = 0; // and reset the processed bytes counter
}
function pump() {
var pos; // position of a EOT character
while ((pos = find(0x04)) >= 0) { // keep going while there's a EOT (0x04) somewhere in the buffer
if (pos == 0) { // if there's more than one EOT in a row, the buffer will now start with a EOT
slice(1); // discard it
continue; // so that the next iteration will start with data
}
process(buffer.slice(0,pos)); // hand off the message
slice(pos+1); // and slice the processed data off the buffer
}
}
function process(msg) { // here's where we do something with a message
if (msg.length > 0) { // ignore empty messages
// here's where you have to decide what to do with the data you've received
// experiment with the protocol
}
}
Completely untested, so there's likely errors. The main thing to gather here is that as data arrives, you buffer it in memory. Once you find a delimiter character in your buffer, you can process the message.