yigitcolakoglu
/
mconnect


								/* ex:ts=4:sw=4:sts=4:et */

								/* -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */

								/**

								 * This program is free software; you can redistribute it and/or modify

								 * it under the terms of the GNU General Public License version 2 as

								 * published by the Free Software Foundation.

								 *

								 * This program is distributed in the hope that it will be useful,

								 * but WITHOUT ANY WARRANTY; without even the implied warranty of

								 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

								 * GNU General Public License for more details.

								 *

								 * You should have received a copy of the GNU General Public License along

								 * with this program; if not, write to the Free Software Foundation, Inc.,

								 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

								 *

								 * AUTHORS

								 * Maciek Borzecki <maciek.borzecki (at] gmail.com>

								 */


								using MConn;


								/**

								 * Device communication channel

								 *

								 * Automatically handle channel encoding.

								 */

								class DeviceChannel : Object {


									public signal void connected();

									public signal void disconnected();

									public signal void packet_received(Packet pkt);


									private InetSocketAddress _isa = null;

									private SocketConnection _conn = null;

									private DataOutputStream _dout = null;

									private DataInputStream _din = null;

									private uint _srcid = 0;


									// channel encryption method

									private Crypt _crypt = null;


									public DeviceChannel(InetAddress host, uint port, Crypt crypt) {

										_isa = new InetSocketAddress(host, (uint16) port);

										_crypt = crypt;

									}


									public async void open() {

										assert(this._isa != null);


										var client = new SocketClient();

										try {

											_conn = yield client.connect_async(_isa);

										} catch (Error e) {

											//

											critical("failed to connect to %s:%u: %s",

													 _isa.address.to_string(), _isa.port,

													 e.message);

											return;

											// TODO emit disconnected signal?

										}


										debug("connected to %s:%u", _isa.address.to_string(), _isa.port);


										// use data streams

										_dout = new DataOutputStream(_conn.output_stream);

										_din = new DataInputStream(_conn.input_stream);

										// messages end with \n\n

										_din.set_newline_type(DataStreamNewlineType.LF);


										// setup socket monitoring

										Socket sock = _conn.get_socket();

										// enable keepalive

										sock.set_keepalive(true);

										// prep source for monitoring events

										SocketSource source = sock.create_source(IOCondition.IN | IOCondition.ERR |

																		IOCondition.HUP);

										source.set_callback((src, cond) => {

												this._io_ready();

												return true;

											});

										// attach source

										_srcid = source.attach(null);


										connected();

									}


									public async void close() {

										debug("closing connection");


										if (_srcid > 0) {

											Source.remove(_srcid);

											_srcid = 0;

										}

										_din.close();

										_dout.close();

										_conn.close();

										_din = null;

										_dout = null;

										_conn = null;

									}


									/**

									 * send:

									 * Possibly blocking

									 *

									 * @param: instance of Packet

									 **/

									public async void send(Packet pkt) {

										string to_send = pkt.to_string() + "\n";

										debug("send data: %s", to_send);

										// _dout.put_string(data);

										try {

											_dout.put_string(to_send);

										} catch (IOError e) {

											critical("failed to send message: %s", e.message);

											// TODO disconnect?

										}

									}


									public async void receive() throws Error {

										size_t line_len;

										// read line up to newline

										string data = yield _din.read_upto_async("\n", -1,

																				 Priority.DEFAULT,

																				 null,

																				 out line_len);

										debug("received line: %s", data);

										// expecting \n\n

										_din.read_byte();

										_din.read_byte();


										Packet pkt = Packet.new_from_data(data);

										if (pkt == null) {

											critical("failed to build packet from data");

											return;

										}


										handle_packet(pkt);

									}


									private async void _io_ready() {

										debug("check for IO");

										try {

											debug("try read");

											this.receive();


										} catch (Error e) {

											critical("error occurred: %d: %s", e.code, e.message);

										}

									}


									private void handle_packet(Packet pkt) {

										debug("handle packet of type: %s", pkt.pkt_type);

										if (pkt.pkt_type == Packet.ENCRYPTED) {

											handle_encrypted_packet(pkt);

										} else {

											// signal that we got a packet

											packet_received(pkt);

										}

									}


									private void handle_encrypted_packet(Packet pkt) {

										// Ecypted packets have 'data' member in body. The 'data'

										// member is an array of strings, each string is base64

										// encoded data, of length appropriate for channel ecryption

										// method.

										Json.Array arr = pkt.body.get_array_member("data");

										if (arr == null) {

											critical("missing data member in encrypted packet");

											return;

										}


										var msgbytes = new ByteArray();

										arr.foreach_element((a, i, node) => {

												debug("node data: %s", node.get_string());

												// encrypted data is base64 encoded

												uchar[] data = Base64.decode(node.get_string());

												var dbytes = new Bytes.take(data);

												ByteArray decrypted = this._crypt.decrypt(dbytes);

												debug("data length: %zu", decrypted.data.length);

												msgbytes.append(decrypted.data);

											});

										// data should be complete now

										debug("total length of packet data: %zu", msgbytes.len);

										// make sure there is \0 at the end

										msgbytes.append({'\0'});

										string decrypted_data = ((string)msgbytes.data).dup();

										debug("decrypted data: %s", decrypted_data);


										Packet dec_pkt = Packet.new_from_data(decrypted_data);

										if (dec_pkt == null) {

											critical("failed to parse decrypted packet");

										} else {

											packet_received(dec_pkt);

										}

									}

								}