-
Rob Swindell authoredRob Swindell authored
binkp.js 39.73 KiB
const binkp_revision = 4;
require('sockdefs.js', 'SOCK_STREAM');
require('fido.js', 'FIDO');
/*
* A binkp implementation...
*
* Create a new instance with New passing a path to place received files
* in to the constructor (defaults to system.temp_dir).
*
* Next, adjust defaults as needed...
* default_zone - if no zone is specified, use this one for all addresses.
* default_domain - if no domain is specified, use this one for all addresses.
* debug - If set, logs all sent/received frames via log(LOG_DEBUG)
* require_md5 - Require that the remote support CRAM-MD5 authentication
* plain_auth_only - Use plain-text authentication always (no CRAM-MD5 auth, no encryption)
* crypt_support - Encryption supported
* timeout - Max timeout
* addr_list - list of addresses handled by this system. Defaults to system.fido_addr_list
* system_name - BBS name to send to remote defaults to system.name
* system_operator - SysOp name to send to remote defaults to system.operator
* system_location - System location to send to remote defaults to system.location
* want_callback - Callback when a file is offered... can rename file, skip file,
* or ACK file without receiving it.
* Parameters: File object, file size, file date, offset
* Return values: this.file.SKIP - Skips the file, will be retransmitted later.
* this.file.ACCEPT - open()s the file and receives it.
* this.file.REJECT - Refuses to take the file... will not be retransmitted later.
* Default value is this.default_want() which accepts all offered
* files.
* rx_callback - Function that is called with two arguments, the filename
* and the BinkP object when a file is received successfully.
* Intended for REQ/TIC processing. This callback can call
* the addFile(filename) method (may not work unless
* ver1_1 is true)
* tx_callback - Function that is called with two arguments, the filename
* and the BinkP object when a file is sent successfully.
* name_ver - Name and version of program in "name/ver.ver.ver" format
*
* Now add any files you wish to send using the addFile(filename) method
*
* Finally, call the connect() or accept() method
* This method will return true if all files were transferred with no errors.
*
* After return, the sent_files and received_files arrays will contain
* lists of successfully transferred files. The failed_sent_files and
* failed_received_files arrays will contain files that failed to
* transfer.
*/
function BinkP(name_ver, inbound, rx_callback, tx_callback)
{
var addr;
if (name_ver === undefined)
name_ver = 'UnknownScript/0.0';
this.name_ver = name_ver;
this.revision = "JSBinkP/" + binkp_revision;
this.full_ver = name_ver + "," + this.revision + ',sbbs' + system.version + system.revision + '/' + system.platform;
if (inbound === undefined)
inbound = system.temp_dir;
this.inbound = backslash(inbound);
this.rx_callback = rx_callback;
this.tx_callback = tx_callback;
this.default_zone = 1;
addr = FIDO.parse_addr(system.fido_addr_list[0], this.default_zone); this.default_zone = addr.zone;
this.senteob = 0;
this.goteob = 0;
this.pending_ack = [];
this.pending_get = [];
this.tx_queue=[];
this.debug = false;
this.nonreliable = false;
this.sent_nr = false;
this.ver1_1 = false;
this.require_md5 = true;
this.plain_auth_only = false;
this.crypt_support = true;
// IREX VER Internet Rex 2.29 Win32 (binkp/1.1) doesn't work with longer challenges
// TODO: Remove this knob
this.cram_challenge_length = 16;
this.require_crypt = true;
this.timeout = 120;
this.addr_list = [];
this.system_name = system.name;
this.system_operator = system.operator;
this.system_location = system.location;
system.fido_addr_list.forEach(function(faddr){this.addr_list.push(FIDO.parse_addr(faddr, this.default_zone, 'fidonet'));}, this);
this.want_callback = this.default_want;
this.wont_crypt = false;
this.will_crypt = false;
this.in_keys = undefined;
this.out_keys = undefined;
this.capabilities = '115200,TCP,BINKP';
this.remote_ver = undefined;
this.remote_operator = undefined;
this.remote_capabilities = undefined;
this.remote_info = {};
this.connect_host = undefined;
this.connect_port = undefined;
this.connect_error = undefined;
this.sent_files = [];
this.failed_sent_files = [];
this.received_files = [];
this.failed_received_files = [];
}
BinkP.prototype.crypt = {
crc32tab:[ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
0x2d02ef8d
],
uint:function(val) {
val &= 0xffffffff;
if (val < 0)
return (val + 0x100000000);
return val;
},
crc32:function(c, b) {
var idx = (c & 0xff) ^ (b & 0xff);
var sft = (c >> 8) & 0xffffff;
var ret = this.uint(this.crc32tab[idx] ^ sft);
return ret;
},
mult32:function(x, y) {
var total;
total = (x * (y & 0xff)) & 0xffffffff;
total += (((x * ((y >> 8) & 0xff)) & 0xffffff) << 8);
total += (((x * ((y >> 16) & 0xff)) & 0xffff) << 16);
total += (((x * ((y >> 24) & 0xff)) & 0xff) << 24);
return (this.uint(total));
},
update_keys:function(keys, c) {
var keyshift;
keys[0] = this.crc32(keys[0], ascii(c));
keys[1] += (keys[0] & 0xff);
keys[1] = this.mult32(keys[1], 134775813) + 1;
keyshift = this.uint(keys[1] >> 24);
keys[2] = this.crc32(keys[2], keyshift);
return ascii(c);
},
init_keys:function(keys, passwd) {
var i;
keys[0] = 305419896;
keys[1] = 591751049;
keys[2] = 878082192;
for (i=0; i<passwd.length; i++)
this.update_keys(keys, passwd[i]);
},
decrypt_byte:function(keys) {
var temp;
temp = (keys[2] & 0xffff) | 2;
return ((temp * (temp ^ 1)) >> 8) & 0xff;
},
decrypt_buf:function(buf, keys) {
var i;
var ret = '';
var ch;
for (i=0; buf !== null && i<buf.length; i++) {
ch = ascii(ascii(buf[i]) ^ this.decrypt_byte(keys));
ret += ch;
this.update_keys(keys, ch);
}
return ret;
},
encrypt_buf:function(buf, keys) {
var t;
var i;
var ret = '';
for (i=0; buf !== null && i<buf.length; i++) {
t = this.decrypt_byte(keys);
this.update_keys(keys, buf[i]);
ret += ascii(ascii(buf[i]) ^ t);
}
return ret;
},
};
BinkP.prototype.reset_eob = function(also_sent) {
if (this.ver1_1) {
this.goteob = 0;
if (also_sent)
this.senteob = 0;
}
};
BinkP.prototype.send_chunks = function(str) {
var ret;
var sent = 0;
while (sent < str.length) {
ret = this.sock.send(str.substr(sent));
if (ret > 0)
sent += ret;
else
return false;
}
return true;
};
BinkP.prototype.send_buf = function(str) {
if (this.out_keys === undefined)
return str;
return this.crypt.encrypt_buf(str, this.out_keys);
};
BinkP.prototype.recv_buf = function(str) {
if (this.in_keys === undefined)
return str;
return this.crypt.decrypt_buf(str, this.in_keys);
};
BinkP.prototype.Frame = function() {};
BinkP.prototype.default_want = function(fobj, fsize, fdate, offset)
{
// Reject duplicate filenames... a more robust callback would rename them.
// Or process the old ones first.
if (this.received_files.indexOf(fobj.name) != -1)
return this.file.REJECT;
// Skip existing files.
if (file_exists(fobj.name))
return this.file.SKIP;
// Accept everything else return this.file.ACCEPT;
};
BinkP.prototype.escapeFileName = function(name)
{
return name.replace(/[^A-Za-z0-9!"#$%&'\(\)*+,\-.\/:;<=>?@\[\]\^_`{|}~]/g, function(match) { return format('\\x%02x', ascii(match)); });
};
BinkP.prototype.unescapeFileName = function(name)
{
return name.replace(/\\x?([0-9a-fA-F]{2})/g, function(match, val) { return ascii(parseInt(val, 16)); });
};
BinkP.prototype.command = {
M_NUL:0,
M_ADR:1,
M_PWD:2,
M_FILE:3,
M_OK:4,
M_EOB:5,
M_GOT:6,
M_ERR:7,
M_BSY:8,
M_GET:9,
M_SKIP:10,
};
BinkP.prototype.command_name = [
"M_NUL",
"M_ADR",
"M_PWD",
"M_FILE",
"M_OK",
"M_EOB",
"M_GOT",
"M_ERR",
"M_BSY",
"M_GET",
"M_SKIP"
];
BinkP.prototype.ack_file = function()
{
var cb_success = true;
var gotlen;
if (this.receiving !== undefined) {
if (this.receiving.position >= this.receiving_len) {
this.receiving.truncate(this.receiving_len);
gotlen = this.receiving.position;
this.receiving.close();
this.receiving.date = this.receiving_date;
if (this.rx_callback !== undefined)
cb_success = this.rx_callback(this.receiving.name, this);
if (cb_success) {
if (this.sendCmd(this.command.M_GOT, this.escapeFileName(this.receiving_name)+' '+gotlen+' '+this.receiving_date))
this.received_files.push(this.receiving.name);
else {
this.failed_received_files.push(this.receiving.name);
log(LOG_WARNING, "Could not send M_GOT for '"+this.receiving.name+"'.");
}
}
else {
if (this.sendCmd(this.command.M_SKIP, this.escapeFileName(this.receiving_name)+' '+this.receiving_len+' '+this.receiving_date)) {
this.failed_received_files.push(this.receiving.name);
log(LOG_WARNING, "Callback returned false for '"+this.receiving.name+"'.");
}
else {
this.failed_received_files.push(this.receiving.name);
log(LOG_WARNING, "Could not send M_SKIP for '"+this.receiving.name+"'.");
}
}
}
else {
log(LOG_WARNING, "Failed to receive the whole file '"+this.receiving.name+"'."); this.receiving.close();
this.failed_received_files.push(this.receiving.name);
}
this.receiving = undefined;
this.receiving_len = undefined;
this.receiving_date = undefined;
this.receiving_name = undefined;
}
};
BinkP.prototype.getCRAM = function(algo, key)
{
var tmp;
if (algo !== 'MD5')
return undefined;
function binary_md5(key)
{
return md5_calc(key, true).replace(/[0-9a-fA-F]{2}/g,function(m){return ascii(parseInt(m, 16));});
}
function str_xor(str1, val)
{
var i;
var ret='';
for (i=0; i<str1.length; i++) {
ret += ascii(str1.charCodeAt(i) ^ val);
}
return ret;
}
tmp = key;
if (tmp.length > 64)
tmp = binary_md5(tmp);
while(tmp.length < 64)
tmp += '\x00';
tmp = md5_calc(str_xor(tmp, 0x5c) + binary_md5(str_xor(tmp, 0x36) + this.cram.challenge), true);
return 'CRAM-'+algo+'-'+tmp;
};
BinkP.prototype.parseArgs = function(data)
{
var ret = data.split(/ /);
var i;
for (i=0; i<ret.length; i++)
ret[i] = this.unescapeFileName(ret[i]);
return ret;
};
/*
* auth_cb(response, this) is called to add files the response parameter is the
* parameter string send with the M_OK message... hopefully either "secure"
* or "non-secure"
*/
BinkP.prototype.connect = function(addr, password, auth_cb, port, inet_host, tls)
{
var pkt;
var i;
this.outgoing = true;
this.will_crypt = false;
this.in_keys = undefined;
this.out_keys = undefined;
if (addr === undefined)
throw new Error("No address specified!");
addr = FIDO.parse_addr(addr, this.default_zone, this.default_domain);
if (!password)
password = '-';
if (password === '-') this.require_md5 = false;
if (port === undefined)
port = addr.binkp_port;
if (inet_host === undefined)
inet_host = addr.inet_host;
log(LOG_INFO, format("Connecting to %s at %s:%u", addr, inet_host, port));
this.connect_host = inet_host;
this.connect_port = port;
if (js.global.ConnectedSocket != undefined) {
if (this.sock !== undefined)
this.sock.close();
try {
this.sock = new ConnectedSocket(inet_host, port, {protocol:'binkp'});
}
catch(e) {
log(LOG_WARNING, "Connection to "+inet_host+":"+port+" failed ("+e+").");
this.connect_error = e;
this.sock = undefined;
return false;
}
}
else {
if (this.sock === undefined)
this.sock = new Socket(SOCK_STREAM, "binkp");
if(!this.sock.connect(inet_host, port)) {
this.connect_error = this.sock.error;
this.sock = undefined;
log(LOG_WARNING, "Connection to "+inet_host+":"+port+" failed.");
return false;
}
}
log(LOG_DEBUG, "Connection to "+inet_host+":"+port+" successful");
if(tls === true) {
log(LOG_INFO, "Negotiating TLS");
this.sock.ssl_session = true;
}
this.authenticated = undefined;
if (this.crypt_support && !this.plain_auth_only && password !== '-')
this.sendCmd(this.command.M_NUL, "OPT CRYPT");
else {
/*
* TODO: This is to work around an apparent incompatibility with
* Radius. I thought this worked with binkd, but it would need
* to be tested again.
*
* Not super-important since using encryption without a password
* is about as "secure" as rot13.
*/
this.wont_crypt = true;
this.require_crypt = false;
}
this.sendCmd(this.command.M_NUL, "SYS "+this.system_name);
this.sendCmd(this.command.M_NUL, "ZYZ "+this.system_operator);
this.sendCmd(this.command.M_NUL, "LOC "+this.system_location);
this.sendCmd(this.command.M_NUL, "NDL "+this.capabilities);
this.sendCmd(this.command.M_NUL, "TIME "+new Date().toString());
this.sendCmd(this.command.M_NUL, "VER "+this.full_ver + " binkp/1.1");
this.sendCmd(this.command.M_ADR, this.addr_list.join(' '));
while(!js.terminated && this.remote_addrs === undefined) {
pkt = this.recvFrame(this.timeout);
if (pkt === undefined || pkt === null)
return false;
}
if (this.authenticated === undefined) {
if (this.plain_auth_only) {
this.sendCmd(this.command.M_PWD, password);
}
else if (this.cram === undefined || this.cram.algo !== 'MD5') {
if (this.require_md5)
this.sendCmd(this.command.M_ERR, "CRAM-MD5 authentication required");
else {
if (this.will_crypt)
this.sendCmd(this.command.M_ERR, "Encryption requires CRAM-MD5 auth");
else
this.sendCmd(this.command.M_PWD, password);
}
}
else {
this.sendCmd(this.command.M_PWD, this.getCRAM(this.cram.algo, password));
}
}
while((!js.terminated) && this.authenticated === undefined) {
pkt = this.recvFrame(this.timeout);
if (pkt === undefined || pkt === null)
return false;
}
if (password !== '-')
this.authenticated = 'secure';
else
this.authenticated = 'non-secure';
if (auth_cb !== undefined)
auth_cb(this.authenticated, this);
if (this.will_crypt) {
if (this.cram === undefined || this.cram.algo !== 'MD5')
this.sendCmd(this.command.M_ERR, "Encryption requires CRAM-MD5 auth");
else {
log(LOG_DEBUG, "Initializing crypt keys.");
this.out_keys = [0, 0, 0];
this.in_keys = [0, 0, 0];
this.crypt.init_keys(this.out_keys, password);
this.crypt.init_keys(this.in_keys, "-");
for (i=0; i<password.length; i++)
this.crypt.update_keys(this.in_keys, password[i]);
}
}
else {
if (this.require_crypt && !this.wont_crypt)
this.sendCmd(this.command.M_ERR, "Encryption required");
}
if (js.terminated) {
this.close();
return false;
}
return this.session();
};
/*
* sock can be either a listening socket or a connected socket.
*
* auth_cb(passwds, this) is called to accept and add
* files if it returns a password, the session is considered secure. auth_cb()
* is explicitly allowed to change the inbound property and call
* this.sendCmd(this.command.M_ERR, "Error String");
*
* It may also set/clear the require_crypt property.
*
* It is up to the auth_cb() callback to enforce the require_md5 property.
*/BinkP.prototype.accept = function(sock, auth_cb)
{
var challenge='';
var i;
var pkt;
var pwd;
var args;
this.outgoing = false;
this.will_crypt = false;
this.in_keys = undefined;
this.out_keys = undefined;
if (sock === undefined || auth_cb === undefined)
return false;
if (this.sock !== undefined)
this.close();
if (sock.is_connected)
this.sock = sock;
else
this.sock = sock.accept();
if (this.sock == undefined || !this.sock.is_connected)
return false;
// IREX VER Internet Rex 2.29 Win32 (binkp/1.1) doesn't work with challenges longer than 32 chars
for (i=0; i < this.cram_challenge_length * 2; i++)
challenge += random(16).toString(16);
// Avoid warning from syncjslint by putting this in a closure.
function hex2ascii(hex)
{
return ascii(parseInt(hex, 16));
}
this.cram = {algo:'MD5', challenge:challenge.replace(/[0-9a-fA-F]{2}/g, hex2ascii)};
this.authenticated = undefined;
if(!this.crypt_support || this.plain_auth_only)
this.wont_crypt = true;
if(!this.plain_auth_only)
this.sendCmd(this.command.M_NUL, "OPT CRAM-MD5-"+challenge+(this.wont_crypt?"":" CRYPT"));
pkt = this.recvFrame(this.timeout);
if (pkt === undefined || pkt === null)
return false;
this.sendCmd(this.command.M_NUL, "SYS "+this.system_name);
this.sendCmd(this.command.M_NUL, "ZYZ "+this.system_operator);
this.sendCmd(this.command.M_NUL, "LOC "+this.system_location);
this.sendCmd(this.command.M_NUL, "NDL 115200,TCP,BINKP");
this.sendCmd(this.command.M_NUL, "TIME "+new Date().toString());
this.sendCmd(this.command.M_NUL, "VER "+this.full_ver + " binkp/1.1");
this.sendCmd(this.command.M_ADR, this.addr_list.join(' '));
while(!js.terminated && this.authenticated === undefined) {
pkt = this.recvFrame(this.timeout);
if (pkt === undefined || pkt === null)
return false;
if (pkt !== null && pkt !== this.partialFrame) {
if (pkt.is_cmd) {
if (pkt.command === this.command.M_PWD) {
args = this.parseArgs(pkt.data);
if (this.will_crypt) {
if (args[0].substr(0, 9) !== 'CRAM-MD5-')
this.sendCmd(this.command.M_ERR, "Encryption requires CRAM-MD5 auth");
}
pwd = auth_cb(args, this);
if (pwd === undefined)
pwd = '-';
if (pwd === '-') {
this.authenticated = 'non-secure'; /*
* It appears the binkd won't encrypt unless there's
* a password, even if they requested CRYPT mode.
*/
this.will_crypt = false;
}
else
this.authenticated = 'secure';
this.sendCmd(this.command.M_OK, this.authenticated);
break;
}
}
}
}
if (this.will_crypt) {
log(LOG_DEBUG, "Initializing crypt keys.");
this.out_keys = [0, 0, 0];
this.in_keys = [0, 0, 0];
this.crypt.init_keys(this.in_keys, pwd);
this.crypt.init_keys(this.out_keys, "-");
for (i=0; i<pwd.length; i++)
this.crypt.update_keys(this.out_keys, pwd[i]);
}
else {
if (this.require_crypt)
this.sendCmd(this.command.M_ERR, "Encryption required");
}
if (js.terminated) {
this.close();
return false;
}
return this.session();
};
BinkP.prototype.file = {
SKIP:0,
ACCEPT:1,
REJECT:2
};
BinkP.prototype.session = function()
{
var i;
var pkt;
var m;
var tmp;
var tmp2;
var ver;
var args;
var size;
var last = Date.now();
var cur_timeout;
// Session set up, we're good to go!
outer:
while(!js.terminated && this.sock !== undefined) {
// We want to wait if we have no more files to send or if we're
// skipping files.
cur_timeout = 0;
if (this.ver1_1) {
// Don't increase the timeout until we've sent the second M_EOB
if (this.senteob >= 2)
cur_timeout = this.timeout;
}
else {
if (this.senteob)
cur_timeout = this.timeout;
}
if (this.sending !== undefined && this.sending.waitingForGet !== undefined && this.sending.waitingForGet)
cur_timeout = this.timeout; pkt = this.recvFrame(cur_timeout);
if (pkt !== undefined && pkt !== this.partialFrame && pkt !== null) {
last = Date.now();
if (pkt.is_cmd) {
cmd_switch:
switch(pkt.command) {
case this.command.M_NUL:
// Ignore
break;
case this.command.M_FILE:
this.ack_file();
args = this.parseArgs(pkt.data);
if (args.length < 4) {
log(LOG_ERROR, "Invalid M_FILE command args: '"+pkt.data+"' from: " + this.remote_addrs);
this.sendCmd(this.command.M_ERR, "Invalid M_FILE command args: '"+pkt.data+"'");
}
tmp = new File(this.inbound + file_getname(args[0]));
switch (this.want_callback(tmp, parseInt(args[1], 10), parseInt(args[2], 10), parseInt(args[3], 10), this)) {
case this.file.SKIP:
this.sendCmd(this.command.M_SKIP, this.escapeFileName(args[0])+' '+args[1]+' '+args[2]);
break;
case this.file.REJECT:
this.sendCmd(this.command.M_GOT, this.escapeFileName(args[0])+' '+args[1]+' '+args[2]);
break;
case this.file.ACCEPT:
size = file_size(tmp.name);
if (size == -1)
size = 0;
if (parseInt(args[3], 10) < 0) {
// Non-reliable mode...
if (this.nonreliable || this.ver1_1) {
this.sendCmd(this.command.M_GET, this.escapeFileName(args[0])+' '+args[1]+' '+args[2]+' '+size);
}
else {
log(LOG_WARNING, "M_FILE Offset of -1 in reliable mode (bug in remote)!");
this.sendCmd(this.command.M_GET, this.escapeFileName(args[0])+' '+args[1]+' '+args[2]+' '+size);
}
}
else {
if (parseInt(args[3], 10) > size) {
log(LOG_ERR, "Invalid offset of "+args[3]+" into file '"+tmp.name+"' size "+size + " from remote: " + this.remote_addrs);
this.sendCmd(this.command.M_ERR, "Invalid offset of "+args[3]+" into file '"+tmp.name+"' size "+size);
}
if (!tmp.open(tmp.exists ? "r+b" : "wb")) {
log(LOG_ERROR, "Error " + tmp.error + " opening file "+tmp.name + " from remote: " + this.remote_addrs );
this.sendCmd(this.command.M_SKIP, this.escapeFileName(args[0])+' '+args[1]+' '+args[2]);
break;
}
this.receiving = tmp;
this.receiving_name = args[0];
this.receiving_len = parseInt(args[1], 10);
this.receiving_date = parseInt(args[2], 10);
log(LOG_INFO, "Receiving file: " + this.receiving.name + format(" (%1.1fKB)", this.receiving_len / 1024.0));
}
break;
default:
log(LOG_ERR, "Invalid return value from want_callback from remote: " + this.remote_addrs);
this.sendCmd(this.command.M_ERR, "Implementation bug at my end, sorry.");
}
break;
case this.command.M_EOB:
this.ack_file();
if (this.pending_ack.length > 0)
log(LOG_WARNING, "We got an M_EOB, but there are still "+this.pending_ack.length+" files pending M_GOT");
else {
if (this.ver1_1) {
if (this.senteob >= 2 && this.goteob >= 2)
break outer;
}
else { if (this.senteob > 0 && this.goteob > 0)
break outer;
}
}
break;
case this.command.M_GOT:
args = this.parseArgs(pkt.data);
for (i=0; i<this.pending_ack.length; i++) {
if (this.pending_ack[i].sendas === args[0]) {
this.sent_files.push(this.pending_ack[i].file.name);
if (this.tx_callback !== undefined)
this.tx_callback(this.pending_ack[i].file.name, this);
this.pending_ack.splice(i, 1);
i--;
}
}
break;
case this.command.M_GET:
args = this.parseArgs(pkt.data);
// If we already sent this file, ignore the command...
for (i=0; i<this.sent_files; i++) {
if (file_getname(this.sent_files[i]) === args[0])
break cmd_switch;
}
// Is this the current "sending" file?
if (this.sending !== undefined && this.sending.sendas === args[0]) {
// Stop waiting for a M_GET
this.sending.waitingForGet = false;
// Now, simply adjust the position in the sending file
this.sending.file.position = parseInt(args[3], 10);
// And send the new M_FILE
this.sendCmd(this.command.M_FILE, this.escapeFileName(this.sending.sendas)+' '+this.sending.file.length+' '+this.sending.file.date+' '+this.sending.file.position);
break;
}
// Now look for it in failed...
for (i=0; i<this.failed_sent_files.length; i++) {
if (file_getname(this.failed_sent_files[i].sendas) === args[0]) {
// Validate the size, date, and offset...
if (file_size(this.failed_sent_files[i].path) != parseInt(args[1], 10) || file_date(this.failed_sent_files[i].path) != parseInt(args[2], 10) || file_size(this.failed_sent_files[i].path) < parseInt(args[3], 10))
break;
// Re-add it
this.addFile(this.failed_sent_files[i].path, this.failed_sent_files[i].sendas, false);
// And remove from failed list
this.failed_sent_files.splice(i, 1);
break;
}
}
// Now, simply adjust the position in a pending file
for (i=0; i<this.tx_queue.length; i++) {
if (file_getname(this.tx_queue[i].file.name) === args[0]) {
// Validate the size, date, and offset...
if (this.tx_queue[i].file.length != parseInt(args[1], 10) || this.tx_queue[i].file.date != parseInt(args[2], 10) || this.tx_queue[i].file.length < parseInt(args[3], 10))
break;
this.tx_queue[i].file.position = parseInt(args[3], 10);
}
}
break;
case this.command.M_SKIP:
args = this.parseArgs(pkt.data);
for (i=0; i<this.pending_ack.length; i++) {
if (this.pending_ack[i].sendas == args[0]) {
this.failed_sent_files.push({path:this.pending_ack[i].file.name, sendas:this.pending_ack[i].sendas});
this.pending_ack.splice(i, 1);
i--;
}
}
if (this.sending !== undefined && this.sending.sendas === args[0]) {
this.sending.file.close();
this.sending = undefined;
} break;
default:
if (pkt.command < this.command_name.length)
tmp = this.command_name[pkt.command];
else
tmp = 'Unknown Command '+pkt.command;
log(LOG_ERROR, "Unhandled "+tmp+" command from remote: " + this.remote_addrs);
this.sendCmd(this.command.M_ERR, "Unhandled command.");
}
}
else {
// DATA packet...
if (this.receiving === undefined) {
if (this.debug)
log(LOG_DEBUG, "Data packet outside of file!");
}
else {
this.receiving.write(pkt.data);
// We need to ACK here...
if (this.receiving.position >= this.receiving_len)
this.ack_file();
}
}
}
if (this.sending === undefined) {
this.sending = this.tx_queue.shift();
if (this.sending === undefined) {
if (this.receiving === undefined) {
if (this.ver1_1) {
if (this.senteob == 0 || (this.goteob))
this.sendCmd(this.command.M_EOB);
}
else {
if (!this.senteob)
this.sendCmd(this.command.M_EOB);
}
}
}
else {
this.pending_ack.push(this.sending);
log(LOG_INFO, "Sending file: " + this.sending.file.name + format(" (%1.1fKB)", this.sending.file.length / 1024.0));
if (this.nonreliable && (this.sending.waitingForGet === undefined || this.sending.waitingForGet)) {
this.sendCmd(this.command.M_FILE, this.escapeFileName(this.sending.sendas)+' '+this.sending.file.length+' '+this.sending.file.date+' -1');
this.sending.waitingForGet = true;
}
else {
this.sendCmd(this.command.M_FILE, this.escapeFileName(this.sending.sendas)+' '+this.sending.file.length+' '+this.sending.file.date+' '+this.sending.file.position);
this.sending.waitingForGet = false;
}
}
}
if (this.sending !== undefined) {
if (this.ver1_1 || this.senteob === 0) {
if (this.sending.waitingForGet !== undefined && !this.sending.waitingForGet) {
if(this.sendData(this.sending.file.read(32767)))
last = Date.now();
if (this.eof || this.sending.file.position >= this.sending.file.length) {
log(LOG_INFO, "Sent file: " + this.sending.file.name + format(" (%1.1fKB)", this.sending.file.position / 1024.0));
this.sending.file.close();
this.sending = undefined;
}
}
}
}
if ((last + this.timeout)*1000 < Date.now())
this.sendCmd(this.command.M_ERR, "Timeout exceeded!");
}
this.close();
if (js.terminated)
return false;
return true;
};
BinkP.prototype.close = function()
{
var i;
var end;
var remain;
// Send an ERR and close.
this.ack_file();
// Any still pending have failed.
for (i=0; i<this.pending_ack.length; i++)
this.failed_sent_files.push({path:this.pending_ack[i].file.name, sendas:this.pending_ack[i].sendas});
for (i=0; i<this.tx_queue.length; i++)
this.failed_sent_files.push({path:this.tx_queue[i].file.name, sendas:this.tx_queue[i].sendas});
if ((!this.goteob) || this.tx_queue.length || this.pending_ack.length || this.pending_get.length)
this.sendCmd(this.command.M_ERR, "Forced Shutdown");
else {
if (this.ver1_1) {
if (this.senteob < 2)
this.sendCmd(this.command.M_EOB);
if (this.senteob < 2)
this.sendCmd(this.command.M_EOB);
}
else {
if (this.senteob < 1)
this.sendCmd(this.command.M_EOB);
}
// Attempt a super-duper graceful shutdown to prevent RST...
if (this.sock !== undefined) {
this.sock.is_writeable = false;
remain = this.timeout;
end = time() + remain;
do {
if (this.sock.recv(2048, remain) == 0)
break;
remain = end - time();
} while (remain > 0);
this.sock.close();
this.sock = undefined;
}
}
this.tx_queue.forEach(function(file) {
file.file.close();
});
};
BinkP.prototype.sendCmd = function(cmd, data)
{
var type;
var tmp;
if (this.sock === undefined)
return false;
if (data === undefined)
data = '';
if (this.debug || cmd == this.command.M_ERR) {
if (cmd < this.command_name.length)
type = this.command_name[cmd];
else
type = 'Unknown Command '+cmd;
log(cmd == this.command.M_ERR ? LOG_NOTICE : LOG_DEBUG, "Sending "+type+" command args: "+data);
}
var len = data.length+1;
len |= 0x8000;
// We'll send it all in one go to avoid sending small packets...
var sstr = this.send_buf(ascii((len & 0xff00)>>8) + ascii(len & 0xff) + ascii(cmd) + data);
if (!this.send_chunks(sstr)) { log(LOG_WARNING, "Send failure");
return false;
}
log(LOG_DEBUG, "Sent " + type + " command");
switch(cmd) {
case this.command.M_EOB:
this.senteob++;
break;
case this.command.M_ERR:
case this.command.M_BSY:
this.sock.close();
this.sock = undefined;
break;
case this.command.M_NUL:
if (data.substr(0, 4) === 'OPT ') {
tmp = data.substr(4).split(/ /);
if (tmp.indexOf('NR'))
this.sent_nr = true;
}
break;
case this.command.M_ADR:
case this.command.M_PWD:
case this.command.M_OK:
break;
default:
this.reset_eob(false);
break;
}
return true;
};
BinkP.prototype.sendData = function(data)
{
var len = data.length;
this.reset_eob(false);
if (this.sock === undefined)
return false;
if (this.debug)
log(LOG_DEBUG, "Sending "+data.length+" bytes of data");
// We'll send it all in one go to avoid sending small packets...
var sstr = this.send_buf(ascii((len & 0xff00)>>8) + ascii(len & 0xff) + data);
if (!this.send_chunks(sstr)) {
log(LOG_WARNING, "Send failure");
return false;
}
return true;
};
BinkP.prototype.recvFrame = function(timeout)
{
var ret;
var type;
var i;
var args;
var options;
var tmp;
var ver;
var avail;
var nullpos;
var buf;
var m;
var binkp_ver;
// Avoid warning from syncjslint by putting this in a closure.
function hex2ascii(hex)
{
return ascii(parseInt(hex, 16));
}
if (this.sock === undefined) {
this.partialFrame = undefined; return undefined;
}
if (timeout === undefined)
timeout = 0;
if (this.partialFrame === undefined) {
ret = new this.Frame();
i = this.sock.recv(1, timeout);
if (i === null) {
log(LOG_INFO, "Error "+this.sock.error+" ("+this.sock.error_str+") in recv() of first byte of packet header, timeout = " + timeout);
this.sock.close();
this.sock = undefined;
return undefined;
}
if (i.length != 1) {
if (!this.sock.is_connected) {
log(LOG_DEBUG, "Remote host closed socket");
this.sock.close();
this.sock = undefined;
return undefined;
}
else if (timeout) {
log(LOG_WARNING, "Timed out receiving first byte of packet header!");
this.sock.close();
this.sock = undefined;
return undefined;
}
return null;
}
buf = i;
i = this.sock.recv(1, this.timeout);
if (i === null) {
log(LOG_INFO, "Error in recv() of second byte of packet header");
this.sock.close();
this.sock = undefined;
return undefined;
}
if (i.length != 1) {
if (!this.sock.is_connected) {
log(LOG_DEBUG, "Remote host closed socket");
this.sock.close();
this.sock = undefined;
return undefined;
}
else if (timeout) {
log(LOG_WARNING, "Timed out receiving second byte of packet header!");
this.sock.close();
this.sock = undefined;
return undefined;
}
return null;
}
buf += i;
buf = this.recv_buf(buf);
ret.length = (ascii(buf[0]) << 8) | ascii(buf[1]);
ret.is_cmd = (ret.length & 0x8000) ? true : false;
ret.length &= 0x7fff;
ret.data = '';
}
else
ret = this.partialFrame;
if (ret.length == 0) {
log(LOG_WARNING, "Remote illegally sent a "+(ret.is_cmd ? 'Command' : 'Data')+" packet with data length of zero. This isn't even allowed in protocol 1.0.");
}
else {
i = this.recv_buf(this.sock.recv(ret.length - ret.data.length, timeout));
if (i == null) {
log(LOG_INFO, "Error in recv() of packet data"); this.sock.close();
this.sock = undefined;
return undefined;
}
if (i.length == 0) {
if (!this.sock.is_connected) {
log(LOG_DEBUG, "Remote host closed socket");
this.sock.close();
this.sock = undefined;
return undefined;
}
else if (timeout) {
log(LOG_WARNING, "Timed out receiving packet data from remote: " + this.remote_addrs);
this.sock.close();
this.sock = undefined;
return undefined;
}
}
ret.data += i;
}
if (ret.data.length < ret.length)
this.partialFrame = ret;
else {
this.partialFrame = undefined;
if (ret.is_cmd) {
ret.command = ret.data.charCodeAt(0);
ret.data = ret.data.substr(1);
}
if (this.debug) {
if (ret.is_cmd) {
if (ret.command < this.command_name.length)
type = this.command_name[ret.command];
else
type = 'Unknown Command '+ret.command;
log(LOG_DEBUG, "Got "+type+" command args: "+ret.data);
}
else
log(LOG_DEBUG, "Got data frame length "+ret.length);
}
if (ret.is_cmd) {
nullpos = ret.data.indexOf(ascii(0));
if (nullpos > -1)
ret.data = ret.data.substr(0, nullpos);
if (ret.command != this.command.M_EOB)
this.reset_eob(false);
switch(ret.command) {
case this.command.M_ERR:
log(LOG_ERROR, "BinkP got fatal error '"+ret.data+"' from remote: " + this.remote_addrs);
this.sock.close();
this.socket = undefined;
return undefined;
case this.command.M_BSY:
log(LOG_WARNING, "BinkP got non-fatal error '"+ret.data+"' from remote: " + this.remote_addrs);
this.sock.close();
this.socket = undefined;
return undefined;
case this.command.M_EOB:
this.goteob++;
break;
case this.command.M_ADR:
if (this.remote_addrs !== undefined) {
this.sendCmd(this.command.M_ERR, "Address already received.");
return undefined;
}
else {
this.remote_addrs = [];
ret.data.split(/ /).forEach(function(addr) {
try {
this.remote_addrs.push(FIDO.parse_addr(addr, this.default_zone)); }
catch (e) {
}
}, this);
}
break;
case this.command.M_OK:
if (this.authenticated !== undefined) {
this.sendCmd(this.command.M_ERR, "Authentication already complete.");
return undefined;
}
else {
log(LOG_INFO, "Authentication successful: " + ret.data);
this.authenticated = ret.data;
}
break;
case this.command.M_NUL:
args = ret.data.split(/ /);
switch(args[0]) {
case 'OPT':
for (i=1; i<args.length; i++) {
if (args[i].substr(0,9) === 'CRAM-MD5-') {
this.cram = {algo:'MD5', challenge:args[i].substr(9).replace(/[0-9a-fA-F]{2}/g, hex2ascii)};
}
else {
switch(args[i]) {
case 'NR':
if (!this.sent_nr)
this.sendCmd(this.command.M_NUL, "NR");
this.nonreliable = true;
break;
case 'CRYPT':
if (!this.wont_crypt) {
this.will_crypt = true;
log(LOG_INFO, "Will encrypt session.");
}
break;
}
}
}
break;
case 'VER':
m = ret.data.match(/^VER (.*) ([^ ]*?)$/);
if (m !== null) {
this.remote_ver = m[1];
log(LOG_INFO, "Peer version: " + this.remote_ver);
binkp_ver = parseFloat(m[2].substr(m[2].indexOf('binkp/') + 6));
// Note: Internet Rex sends "VER Internet Rex 2.67 beta 1a OS/2 (binkp/1.1)"
if (m[2] !== 'binkp/1.1' && binkp_ver > 1.0) {
log(LOG_WARNING, 'Peer ended their VER with " '+m[2]+'" instead of the required " binkp/1.1", but we\'re assuming binkp 1.1 anyway');
}
log(LOG_DEBUG, "Parsed BinkP version: " + binkp_ver);
this.ver1_1 = binkp_ver >= 1.1;
}
break;
case 'ZYZ':
this.remote_operator = args.slice(1).join(' ');
break;
case 'NDL':
this.remote_capabilities = args.slice(1).join(' ');
break;
default:
this.remote_info[args[0]] = args.slice(1).join(' ');
break;
}
}
}
else
this.reset_eob(false);
} return ret;
};
BinkP.prototype.addFile = function(path, sendas, waitget)
{
var file = new File(path);
this.reset_eob(true);
if (sendas === undefined)
sendas = file_getname(path);
if (waitget === undefined)
waitget = true;
if (!file.open("rb", true)) {
log(LOG_WARNING, "Error " + file.error + " opening '"+file.name+"'. Not sending.");
return false;
}
if (this.debug)
log(LOG_DEBUG, "Adding '"+path+"' as '"+sendas+"'");
this.tx_queue.push({file:file, sendas:sendas, waitingForGet:waitget});
return true;
};