/*
 * Copyright (c) 2018 Thomas Pornin <pornin@bolet.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining 
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net.Sockets;
using System.Text;
using System.Threading;

using Asn1;
using Crypto;
using IO;
using SSLTLS;
using XKeys;

/*
 * A simple command-line application that runs a client that connects
 * to a provided server. This is meant for debug purposes.
 */

public class Client {

	public static void Main(string[] args)
	{
		try {
			new Client().Run(args);
		} catch (Exception e) {
			Console.WriteLine(e.ToString());
			Environment.Exit(1);
		}
	}

	void Run(string[] args)
	{
		bool verbose = true;
		bool trace = false;
		string host = null;
		string sni = null;
		List<string> csNames = null;
		List<string> hsNames = null;
		int vmin = 0;
		int vmax = 0;
		for (int i = 0; i < args.Length; i ++) {
			string a = args[i];
			if (!a.StartsWith("-")) {
				if (host != null) {
					throw new Exception(
						"duplicate host name");
				}
				host = a;
				continue;
			}
			a = a.Substring(1).ToLowerInvariant();
			switch (a) {
			case "v":
				verbose = true;
				break;
			case "q":
				verbose = false;
				break;
			case "trace":
				trace = true;
				break;
			case "sni":
				if (sni != null) {
					throw new Exception(
						"duplicate SNI");
				}
				if (++ i >= args.Length) {
					throw new Exception(
						"no SNI provided");
				}
				sni = args[i];
				break;
			case "nosni":
				if (sni != null) {
					throw new Exception(
						"duplicate SNI");
				}
				sni = "";
				break;
			case "cs":
				if (++ i >= args.Length) {
					throw new Exception(
						"no cipher names provided");
				}
				if (csNames == null) {
					csNames = new List<string>();
				}
				AddNames(csNames, args[i]);
				break;
			case "hs":
				if (++ i >= args.Length) {
					throw new Exception(
						"no hash-and-sign provided");
				}
				if (hsNames == null) {
					hsNames = new List<string>();
				}
				AddNames(hsNames, args[i]);
				break;
			case "vmin":
				if (vmin != 0) {
					throw new Exception(
						"duplicate minimum version");
				}
				if (++ i >= args.Length) {
					throw new Exception(
						"no minimum version provided");
				}
				vmin = SSL.GetVersionByName(args[i]);
				break;
			case "vmax":
				if (vmax != 0) {
					throw new Exception(
						"duplicate maximum version");
				}
				if (++ i >= args.Length) {
					throw new Exception(
						"no maximum version provided");
				}
				vmax = SSL.GetVersionByName(args[i]);
				break;
			default:
				throw new Exception(string.Format(
					"Unknown option: '-{0}'", a));
			}
		}

		if (host == null) {
			throw new Exception("no host name provided");
		}
		int j = host.LastIndexOf(':');
		int port;
		if (j < 0) {
			port = 443;
		} else {
			if (!Int32.TryParse(host.Substring(j + 1), out port)
				|| port <= 0 || port > 65535)
			{
				throw new Exception("invalid port number");
			}
			host = host.Substring(0, j);
		}
		if (sni == null) {
			sni = host;
		}
		int[] css = null;
		if (csNames != null) {
			css = new int[csNames.Count];
			for (int i = 0; i < css.Length; i ++) {
				css[i] = SSL.GetSuiteByName(csNames[i]);
			}
		}
		int[] hss = null;
		if (hsNames != null) {
			hss = new int[hsNames.Count];
			for (int i = 0; i < hss.Length; i ++) {
				hss[i] = SSL.GetHashAndSignByName(hsNames[i]);
			}
		}
		if (vmin != 0 && vmax != 0 && vmin > vmax) {
			throw new Exception("invalid version range");
		}

		/*
		 * Connect to the designated server.
		 */
		TcpClient tc = new TcpClient(host, port);
		Socket sock = tc.Client;
		Stream ns = tc.GetStream();
		if (trace) {
			MergeStream ms = new MergeStream(ns, ns);
			ms.Debug = Console.Out;
			ns = ms;
		}
		SSLClient ssl = new SSLClient(ns);
		if (sni != "") {
			ssl.ServerName = sni;
		}
		if (css != null) {
			ssl.SupportedCipherSuites = css;
		}
		if (hss != null) {
			ssl.SupportedHashAndSign = hss;
		}
		if (vmin != 0) {
			ssl.VersionMin = vmin;
		}
		if (vmax != 0) {
			ssl.VersionMax = vmax;
		}

		/*
		 * This is a debug tool; we accept the server certificate
		 * without validation.
		 */
		ssl.ServerCertValidator = SSLClient.InsecureCertValidator;

		/*
		 * Force a Flush. There is no application data to flush
		 * at this point, but as a side-effect it forces the
		 * handshake to complete.
		 */
		ssl.Flush();

		if (verbose) {
			Console.WriteLine("Handshake completed:");
			Console.WriteLine("  Version      = {0}",
				SSL.VersionName(ssl.Version));
			Console.WriteLine("  Cipher suite = {0}",
				SSL.CipherSuiteName(ssl.CipherSuite));
		}

		/*
		 * Now relay data back and forth between the connection
		 * and the console. Since the underlying SSL stream does
		 * not support simultaneous reads and writes, we use
		 * the following approximation:
		 *
		 *  - We poll on the socket for incoming data. When there
		 *    is some activity, we assume that some application
		 *    data (or closure) follows, and we read it. It is
		 *    then immediately written out (synchronously) on
		 *    standard output.
		 *
		 *  - When waiting for read activity on the socket, we
		 *    regularly (every 200 ms) check for data to read on
		 *    standard input. If there is, we read it, and send
		 *    it synchronously on the SSL stream.
		 *
		 *  - The data reading from console is performed by
		 *    another thread.
		 *
		 * Since SSL records are read one by one, we know that,
		 * by using a buffer larger than 16 kB, a single Read()
		 * call cannot leave any buffered application data.
		 */
		ssl.CloseSub = false;
		Thread t = new Thread(new ThreadStart(CRThread));
		t.IsBackground = true;
		t.Start();
		byte[] buf = new byte[16384];
		Stream stdout = Console.OpenStandardOutput();
		for (;;) {
			if (sock.Poll(200000, SelectMode.SelectRead)) {
				int rlen = ssl.Read(buf, 0, buf.Length);
				if (rlen < 0) {
					Console.WriteLine(
						"Connection closed.\n");
					break;
				}
				stdout.Write(buf, 0, rlen);
			} else {
				while (CRHasData()) {
					int rlen = CRRead(buf, 0, buf.Length);
					if (rlen < 0) {
						ssl.Close();
						break;
					}
					if (rlen > 0) {
						ssl.Write(buf, 0, rlen);
					}
				}
			}
		}
		sock.Close();
	}

	static void AddNames(List<string> d, string str)
	{
		foreach (string name in str.Split(
			new char[] { ',', ':', ';' },
			StringSplitOptions.RemoveEmptyEntries))
		{
			d.Add(name.Trim());
		}
	}

	object consoleReadLock = new object();
	byte[] crBuf = new byte[16384];
	int crPtr = 0;
	bool crClosed = false;

	bool CRHasData()
	{
		lock (consoleReadLock) {
			return crPtr != 0 || crClosed;
		}
	}

	int CRRead(byte[] buf, int off, int len)
	{
		lock (consoleReadLock) {
			if (crPtr == 0 && crClosed) {
				return -1;
			}
			int rlen = Math.Min(len, crPtr);
			Array.Copy(crBuf, 0, buf, off, rlen);
			if (rlen > 0 && rlen < crPtr) {
				Array.Copy(crBuf, rlen, crBuf, 0, crPtr - rlen);
			}
			crPtr -= rlen;
			Monitor.PulseAll(consoleReadLock);
			return rlen;
		}
	}

	void CRThread()
	{
		byte[] buf = new byte[crBuf.Length];
		Stream stdin = Console.OpenStandardInput();

		for (;;) {
			lock (consoleReadLock) {
				while (crPtr == crBuf.Length) {
					Monitor.Wait(consoleReadLock);
				}
			}
			int rlen = stdin.Read(buf, 0, buf.Length);
			lock (consoleReadLock) {
				Monitor.PulseAll(consoleReadLock);
				if (rlen < 0) {
					crClosed = true;
					break;
				}
				Array.Copy(buf, 0, crBuf, crPtr, rlen);
				crPtr += rlen;
			}
		}
	}
}