import java.io.*;
import java.net.*;
/**
 * 這個類實現了一個簡單的單線程的代理服務器
 */
public class SimpleProxyServer {
	/** 主函數解析參數并把參數傳遞給runServer */
	public static void main(String[] args) throws IOException {
		try {
			// 檢查參數的個數
			if (args.length != 3)
				throw new IllegalArgumentException("Wrong number of args.");
			// 獲得命令行參數: 我們要代理的主機和端口
			String host = args[0];
			int remoteport = Integer.parseInt(args[1]);
			int localport = Integer.parseInt(args[2]);
			// 顯示開始信息
			System.out.println("Starting proxy for " + host + ":" +
				remoteport + " on port " + localport);
			// 開始運行這個服務器
			runServer(host, remoteport, localport); // 永不返回
		}
		catch (Exception e) {
			System.err.println(e);
			System.err.println("Usage: java SimpleProxyServer " +
				"<host> <remoteport> <localport>");
		}
	}

	/**
	 * 這個方法運行一個單線程的代理服務器，它在指定的本地端口上
	 * 代理一個主機上的遠程端口。它用不返回。
	 */
	public static void runServer(String host, int remoteport, int localport)
		throws IOException {
		// 創建一個ServerSocket來監聽連接
		ServerSocket ss = new ServerSocket(localport);
		// 為客戶端到服務器和服務器到客戶端創建緩沖區
		// 我們指定緩沖區為final，使它能夠在下面的匿名類中能夠被使用
		// 注意在每個方向上交換量上的假定
		final byte[] request = new byte[1024];
		byte[] reply = new byte[4096];
		// 這是一個用不返回的服務器，故進入一個無限循環
		while(true) {
			// 保持與客戶端和與服務器連接的socket的變量
			Socket client = null, server = null;
			try {
				// 等待一個本地端口的連接
				client = ss.accept();
				// 獲取客戶流，把他們定義成final使得他們在下面的匿名
				// 類中能夠被使用
				final InputStream from_client = client.getInputStream();
				final OutputStream to_client = client.getOutputStream();
				// 建立一個與真實服務器的連接
				// 如果我們不能連上服務器，發送一個錯誤給客戶端
				// 取消連接，等待下次連接
				try { server = new Socket(host, remoteport); }
				catch (IOException e) {
					PrintWriter out = new PrintWriter(to_client);
					out.print("Proxy server cannot connect to " + host + ":"+
						remoteport + ":\n" + e + "\n");
					out.flush();
					client.close();
					continue;
				}
				// 獲得服務器的流
				final InputStream from_server = server.getInputStream();
				final OutputStream to_server = server.getOutputStream();
				// 創建一個線程讀取客戶端的請求，把請求傳遞給服務器，我們不得不
				// 使用一個獨立的線程，因為請求和響應是異步的
				Thread t = new Thread() {
					public void run() {
						int bytes_read;
						try {
							while((bytes_read=from_client.read(request))!=-1) {
								to_server.write(request, 0, bytes_read);
								to_server.flush();
							}
						}
						catch (IOException e) {}
						// 客戶端關閉了同我們的連接，那么也就關閉了我們與服務器的
						// 連接。這將造成主線程中服務器與客戶端之間的循環退出
						try {to_server.close();} catch (IOException e) {}
					}
				};
				// 開始客戶端到服務器請求線程的運行
				t.start();
				// 同時，在主線程中，讀取服務器的響應，并把它們傳遞給客戶端。這將
				// 與上面提到的客戶端到服務器的請求線程并行執行
				int bytes_read;
				try {
					while((bytes_read = from_server.read(reply)) != -1) {
						to_client.write(reply, 0, bytes_read);
						to_client.flush();
					}
				}
				catch(IOException e) {}
				// 服務器關閉同我們的連接，那么我們關閉與客戶端的連接
				// 這將使另外一個線程退出
				to_client.close();
			}
			catch (IOException e) { System.err.println(e); }
			finally { // 不管發生什么關閉線程
				try {
					if (server != null) server.close();
					if (client != null) client.close();
				}
				catch(IOException e) {}
			}
		}
	}
}