cryo

#!/usr/bin/env node
/* networked cry node -- 2012 -- pancake@nopcode.org */

var net = require ('net');
var exec = require ("child_process").exec
var spawn = require ("child_process").spawn
var rl = require ('readline').createInterface (
		process.stdin, process.stdout, completer);
var use_udp = true
var cmd_notify = "mplayer "+__dirname+"/lib/message.oga"
var cmd_error = "mplayer "+__dirname+"/lib/error.oga"
var UUID = 0;
var port = 9999
var host = undefined
var iam = process.env ["USER"] || undefined
var key = ''
var udp_port = 9999;
var cry = __dirname + "/cry"
var forward = false; // not yet implemented
var reconnect = true;
var reconnect_every = 5;

/* --- */
var p = spawn ("sh", [ "-c", "cry -l| grep ^p|head -n1|awk '{print $2}'" ])
p.stdout.on ('data', function (data) {
	iam = (""+data).trim ();
});
/* --- */

switch (process.argv.length) {
case 4:
	key = process.argv[2]
	udp_port = port = process.argv[3]
	break;
case 5:
	key = process.argv[2]
	host = process.argv[3]
	udp_port = port = process.argv[4]
	break;
default:
	console.log ("client: cryo [pubkey] [host] [port]")
	console.log ("server: cryo [pubkey] [port]")
	process.exit (1);
	break;
}

rl.set_prompt = function (x) {
	var id = peer? peer.uuid: -1;
	if (x) rl.setPrompt ('['+key+'] \x1b[32m<'+x+':'+id+'> \x1b[0m', (key+x+id).length+7);
}
rl.set_prompt (iam)
rl.prompt ();

function system(x) {
	var c = x.split (/ /g)
	spawn(c[0], c.splice(1))
}

var cryo_import = function (name, key) {
	var p = spawn (cry, ['-i', name, '-']);
	var body = "";
	p.stdout.on ('data', function (data) { body += data; });
	p.stdout.on ('close', function (code) { print (body) });
	p.stdin.on ("drain", function () { p.stdin.end (); });
	p.stdin.write (key)
}

var enc = (function (msg, cb) {
	var p = spawn (cry, ['-e', key]);
	var body = "";
	p.stdout.on ('data', function (data) { body += data; });
	p.stdout.on ('close', function (code) { cb (body); });
	p.stdin.on ("drain", function () { p.stdin.end (); });
	p.stdin.write (msg)
})

var dec = (function (msg, cb) {
	var oclosed = false;
	var eclosed = false;
	var body = "";
	var nkey = ""
	var p = spawn (cry, ['-d']);
	p.stderr.on ('data', function (data) {
		nkey = (""+data).trim ()
		if (nkey.indexOf (' ') != -1)
			console.error ("ERROR "+nkey);
	});
	p.stderr.on ('close', function (code) { eclosed = true; if (oclosed) cb (nkey, body); });
	p.stdout.on ('data', function (data) { body += data; });
	p.stdout.on ('close', function (code) { oclosed = true; if (eclosed) cb (nkey, body); });
	p.stdin.on ("drain", function () { p.stdin.end (); });
	p.stdin.write (msg.replace (/\r/g,''));
})

var peers = [];
var peer = undefined

function set_peer (n) {
	var i = 0;
	for (var p in peers) {
		if (n == i++) {
			if ((peer = peers[p])) {
				key = peer.key
				return true;
			}
			return false;
		}
	}
	return false;
}

function list_peers () {
	var i = 0;
	for (var x in peers) {
		var p = peers[x];
		if (p) {
			var pn = "";
			if (p.pub_name)
				pn = "@("+p.pub_name+")";
			console.log (peer == p? '*': ' ',
				i, p.host+":"+p.port, p.key, pn);
		}
		i++;
	}
}

var offline = function () {
	status ("offline");
	system (cmd_error);
}
var sendmsg = offline;

function peersend (data, type) {
	if (type) {
		try { if (peer) peer.sock.write (type+"\n"+data)
		} catch (e) { print ("cannot write 0", e) }
		return;
	}
	type = "msg";
	enc (data, function (x) {
		try { if (peer) peer.sock.write (type+"\n"+x)
		} catch (e) { print ("cannot write 1") }
	});
}
function cryo_disconnect (host, port) {
	if (peer) peer.sock.destroy ();
}

var _status = undefined;

function status(x) {
	if (x) { print (x); return _status = x; }
	return _status;
}

function print (x) {
	var d = new Date ();
	function atoi (x) { if (x<10) return "0"+x; return x; }
	now = ((""+x).indexOf ('<') != -1)?
		atoi (d.getHours ()) + ":" + atoi (d.getMinutes ())+" ": "";
	console.log ("\r\x1b[0K"+now+x)
	rl.prompt (true);
}

function cryo_decode_msg (uuid, data) {
	var noff = data.indexOf ('\n');
	if (noff != -1) {
		header = data.substring (0, noff).split (' ')
		data = data.substring (noff+1)
	} else header = [];

	var input = (""+data).replace (/==/,'_=').split ('=');
	for (var i=0; i<input.length;i++) {
		var str = input[i].trim ().replace(/_/,'=') + "=";
		if (str == "=") continue;
		switch (header[0]) {
		case 'pong':
			dec (str, function (x, y) {
				print ("PONG <"+x+":"+uuid+"> "+y.trim ())
			});
			break;
		case 'ping':
			dec (str, function (x, y) {
				enc (y.trim(), function (x2) {
					sendmsg (x2, "pong")
					print ("PONG <"+x+":"+uuid+"> "+y.trim ())
				});
			});
			break;
		case 'pub':
			print ("Received public key from "+header[1])
			console.log (data)
			console.log ("Type /import to accept it")
			peer.pub_name = header[1];
			peer.pub = data
			rl.prompt (true);
			break;
		case 'msg':
			dec (str, function (x, y) {
				rl.set_prompt (x);
				system (cmd_notify);
				print ("<"+key+":"+uuid+"> "+y.trim ())
			});
			break;
		default:
			print ("Invalid packet");
			break;
		}
	}
}

function cryo_pub (k) {
	var p = spawn (cry, ['-p', k]);
	var pubkey = "";
	p.stdout.on ('data', function (data) {
		pubkey += (""+data)
	});
	p.stdout.on ('close', function (data) {
		if (pubkey.length>0) {
			sendmsg (pubkey, "pub "+k);
		} else print ("Cannot find pubkey");
	});
}

function newPeer (c) {
	var uuid = UUID++;
	print ("peer "+uuid+" connected");
	c.setNoDelay ();
	var p = peers[uuid] = {
		'host': c.remoteAddress,
		'port': c.remotePort,
		'uuid': uuid,
		'key' : key,
		'sock': c
	};
	if (!peer) peer = p;
	sendmsg = peersend
	return p;
}

function delPeer (p) {
	print ('peer disconnected');
	if (peer == p) {
		sendmsg = offline;
		peer = undefined
	}
	delete peers[p.uuid]
}

function cryo_connect (host, port) {
	status ("connecting to "+host+":"+port);
	var c = net.connect (port, host, function () {
		var p = newPeer (c);
		c.on ('data', function (data) { cryo_decode_msg (p.uuid, ""+data) });
		c.on ('end', function () { delPeer (p); });
	});
	c.on ('error', offline);
}

function cryo_listen (port) {
	/* listen */
	var server = net.createServer (function (c) {
		var p = newPeer (c);
		c.on ('data', function (data) { cryo_decode_msg (p.uuid, ""+data) });
		c.on ('end', function () { delPeer (p); });
		c.on ('error', offline);
	});
	server.listen (port, function () {
		print ('listening on '+ port);
	});
}

/* main */
if (host) {
	cryo_connect (host, port);
	if (reconnect) {
		setInterval (function (x) {
			if (sendmsg == offline) {
				if (status () == "connecting")
					return;
				cryo_connect (host, port);
			}
		}, reconnect_every*1000);
	}
} else cryo_listen (port);

var commands = {
	'help': { callback: function () {
			for (var k in commands) {
				var av = commands[k].help.split("\t")
				nsp = Array (15-(av[0].length+k.length)).join (' ')
				console.log ("/"+k+" "+av[0]+nsp+av[1])
			}
		}, help: "\tshow this help message" },
	'connect': { callback: function(args) {
			if (args[1]) host = args[1]
			if (args[2]) port = args[2]
			cryo_disconnect ();
			cryo_connect (host, port)
		}, help: "[h p]\tconnect to remote host and port" },
	'disconnect': { callback: function() {
			cryo_disconnect ()
		}, help: "\tunlink current peer" },
	'key': { callback: function (args) {
			if (args[1]) {
				if (peer) peer.key = key = args[1];
			} else print (key);
		}, help: "[k]\tset pub key for current peer" },
	'keys': { callback: function (args) {
			cryo_cmd ("!cry -l")
		}, help: "\talias for !cry -l" },
	'ping': { callback: function (args) {
			var uuid = ""+Math.floor (Math.random ()*999999)
			console.log ("PING "+uuid)
			enc (uuid, function (x) {
				sendmsg (x, "ping")
			});
		}, help: "\tsend ping. expect pong" },
	'peer': { callback: function (args) {
			if (args[1]) {
				if (!set_peer (args[1]))
					print ("invalid peer id")
			} else if (peer) print (peer.uuid);
		}, help: "[p]\tselect peer" },
	'exit': { callback: function () {
			console.log ("byebye");
			process.exit (0);
		}, help: "\tquit this program" },
	'import': { callback: function () {
			if (peer && peer.pub_name && peer.pub) {
				cryo_import (peer.pub_name, peer.pub);
				peer.pub_name = peer.pub = undefined;
			} else print ("Nothing to import");
		}, help: "\timport given key" },
	'list': { callback: function() {
			list_peers ()
		}, help: "\tlist all peers" },
	'lan': { callback: function(args) {
			var cmd = args.splice(1).join (' ')
			var client = dgram.createSocket ("udp4");
			//client.setBroadcast (true)
			client.bind ()
			client.setBroadcast (true)
			enc (cmd, function (str, y) {
				str = new Buffer ("msg\n"+str)
				client.send (str, 0, str.length, udp_port, "255.255.255.255", function (err, bytes) {
				//client.send (str, 0, str.length, udp_port, "127.0.0.1", function (err, bytes) {
					client.close();
				});
			});
		}, help: "[m]\tsend lan message (udp broadcast)" },
	'pub': { callback: function(args) {
			if (args[1]) cryo_pub (args[1]);
			else console.log ("Missing argument");
		}, help: "\tannounce public key" }
}

var n=0, completions = new Array (commands.length)
for (var k in commands) completions[n++] = "/"+k;

function completer (line) {
	var hits = completions.filter (function(c) { if (c.indexOf (line) == 0) { return c; }});
	return [hits && hits.length ? hits : completions, line];
}

function cryo_cmd (str) {
	switch (str[0]) {
	case '!':
		var p = spawn ("sh", ["-c", str.substring (1)])
		if (p) {
			var body = "";
			p.stdout.on ('data', function (data) { body += data; });
			p.stdout.on ('close', function (data) { print (body.trim()) });
		}
		break;
	case '/':
		var args = str.substring (1).split (/ /);
		var cb = commands[args[0]];
		if (cb) cb.callback (args)
		else console.error ("Invalid command.");
		break;
	default:
		if (str.length>0) sendmsg (str);
	}
}
rl.on ('line', function (line) {
	var str = line.trim ();
	cryo_cmd (str);
	rl.prompt ();
}).on ('close', function () {
	console.log ("^D");
	process.exit (0);
});

if (use_udp && udp_port != 0) {
	var dgram = require('dgram');
	print ("listening udp packets on port "+udp_port)

	var server = dgram.createSocket ("udp4", function (msg, rinfo) {
		cryo_decode_msg ('udp', ""+msg)
	});
	server.bind (udp_port, '0.0.0.0')
}