/**

 * TCP 接收端.<br>

 * 监听

 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

 * @version 1.0

 */

public class TCPReceive implements ServerReceive {

	@Override public void onCreate() {

	}

}

package shendi.nat.bean;

import shendi.nat.protocol.ServerProtocol;

/**

 * 穿透信息,包含需要访问的ip和端口,状态等.

 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

 * @version 1.0

 */

public class NATInfo {

	/**

	 * 内网电脑的 ip.

	 */

	private String ip;

	/**

	 * 内网电脑的端口.

	 */

	private int port;

	/**

	 * 服务端对应的端口(经济原因,这里应是域名)

	 */

	private int serverPort;

	/**

	 * 使用的什么协议.

	 */

	private String protocol;

	/**

	 * 当前穿透(隧道)状态.

	 */

	private NATState state = NATState.离线;

	/**

	 * 协议对应的服务端.

	 */

	private ServerProtocol server;

	/**

	 * 创建穿透信息.

	 * @param ip 内网电脑的ip

	 * @param port 内网电脑的端口

	 * @param serverPort 对应的服务器的端口

	 * @param protocol 使用的什么协议

	 */

	public NATInfo(String ip, int port, int serverPort,String protocol) {

		this.ip = ip;

		this.port = port;

		this.serverPort = serverPort;

		this.protocol = protocol;

	}

	public String getIp() { return ip; }

	public int getPort() { return port; }

	public int getServerPort() { return serverPort; }

	public String getProtocol() { return protocol; }

	public NATState getState() { return state; }

	public void setState(NATState state) { this.state = state; }

	public ServerProtocol getServer() { return server; }

	public void setServer(ServerProtocol server) { this.server = server;}

}

// 添加隧道,增加一个id进入map里然后返回数据就ok了.

case "add":

	// 格式为 add;ip;端口;协议

	// 这里的 ip 和端口都是客户端的.

	String ip = datas[0];

	int port = Integer.parseInt(datas[1]);

	int serverPort = Integer.parseInt(datas[2]);

	String protocol = datas[3];

	// 判断端口是否占用,占用则提醒,

	try {

		new ServerSocket(serverPort).close();

		// 返回信息,返回格式为 ok;id;端口

		NAT_INFOS.put(String.valueOf(id), new NATInfo(ip, port, serverPort, protocol));

		StringBuilder b = new StringBuilder();

		b.append("ok;"); b.append(id); b.append(';'); b.append(serverPort);

		output.write(b.toString().getBytes()); output.flush();

		id++;

	} catch (IOException e) {

		Log.printAlarm("TCP接收器新增隧道失败,端口被占用,客户请求 ip: " + requestIp);

		output.write("error;端口被占用,请更换端口".getBytes()); output.flush();

	}

	break;

package shendi.nat.protocol;

import shendi.nat.bean.NATInfo;

import shendi.nat.bean.NATState;

/**

 * 隧道协议抽象类,继承此类来创建一个隧道协议.<br>

 * 创建的隧道协议需要在 protocol.properties 中进行配置.<br>

 * 配置形式为 协议名=类全路径.<br>

 * 如果要实现构造方法,请确保线程安全,请勿执行耗时操作.

 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

 * @version 1.0

 */

public abstract class ServerProtocol {

	/**

	 * 死循环的标志位,true运行,false关闭.

	 */

	private boolean state = true;

	/**

	 * 隧道信息.

	 */

	private NATInfo info;

	/**

	 * 开启此协议.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param info 隧道的信息.

	 */

	public final void start(NATInfo info) {

		info.setState(NATState.在线);

		this.info = info;

		new Thread(() ->{

			onCreate(info);

			while (state) { run(); }

			onStop();

		}).start();

	}

	/**

	 * 关闭此协议,关闭后就代表此对象将被清理.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 */

	public final void stop() { info.setState(NATState.离线); state = false; }

	/**

	 * 在被创建的时候调用.<br>

	 * 用于初始化.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param info 隧道的信息.

	 */

	protected abstract void onCreate(NATInfo info);

	/**

	 * 执行具体操作逻辑.<br>

	 * 此方法会被持续调用,请确保线程安全.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 */

	protected abstract void run();

	/**

	 * 被关闭时调用.<br>

	 * 用于关闭连接,恢复状态等.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 */

	protected abstract void onStop();

	/**

	 * 获取当前隧道信息.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @return {@link NATInfo}

	 */

	public NATInfo getInfo() { return info; }

}

package shendi.nat.server.receive;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.HashMap;

import shendi.kit.config.ConfigurationFactory;

import shendi.kit.log.Log;

import shendi.nat.bean.NATInfo;

import shendi.nat.bean.NATState;

import shendi.nat.protocol.ServerProtocol;

/**

 * TCP 接收端.<br>

 * 接收到消息后进行处理,如果消息是正确的则会创建指定服务端.

 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

 * @version 1.0

 */

public class TCPReceive implements ServerReceive {

	/**

	 * TCP 服务端套接字.

	 */

	private ServerSocket server;

	/**

	 * 当前用户开启的端口.<br>

	 * 隧道id=隧道信息的形式.

	 */

	private static final HashMap<String,NATInfo> NAT_INFOS = new HashMap<>();

	/**

	 * 分配的,隧道id

	 */

	private static int id = 0;

	public TCPReceive() throws IOException {

		// 创建服务端,绑定指定端口,端口从配置文件获取

		String port = ConfigurationFactory.getConfig("config").getProperty("server.port");

		server = new ServerSocket(Integer.parseInt(port));

	}

	@Override public void onCreate() {

		while (true) {

			try {

				Socket socket = server.accept();

				// 开启线程

				new Thread(() -> {

					try (BufferedInputStream input = new BufferedInputStream(socket.getInputStream());

							BufferedOutputStream output = new BufferedOutputStream(socket.getOutputStream())) {

						// 接收的数据不会大于 1024 字节

						byte[] data = new byte[1024];

						int len = input.read(data);

						// 处理数据

						if (len > 0) {

							String sData = new String(data,0,len);

							String[] datas = sData.split(";");

							// 获取到请求 IP 地址

							String requestIp = socket.getInetAddress().getHostAddress();

							// 加锁,避免高并发出问题

							synchronized (NAT_INFOS) {

								// 获取到数据类型 按照正常思路来,数组越界也就等于数据是错误的

								switch (datas[0]) {

								// 添加隧道,增加一个id进入map里然后返回数据就ok了.

								case "add":

									// 格式为 add;ip;端口;协议

									// 这里的 ip 和端口都是客户端的.

									String ip = datas[1];

									int port = Integer.parseInt(datas[2]);

									int serverPort = Integer.parseInt(datas[3]);

									String protocol = datas[4];

									// 判断端口是否占用,占用则提醒,

									try {

										new ServerSocket(serverPort).close();

										// 返回信息,返回格式为 ok;id;端口

										NAT_INFOS.put(String.valueOf(id), new NATInfo(ip, port, serverPort, protocol));

										StringBuilder b = new StringBuilder();

										b.append("ok;"); b.append(id); b.append(';'); b.append(serverPort);

										output.write(b.toString().getBytes()); output.flush();

										id++;

									} catch (IOException e) {

										Log.printAlarm("TCP接收器新增隧道失败,端口被占用,客户请求 ip: " + requestIp);

										output.write("error;端口被占用,请更换端口".getBytes()); output.flush();

									}

									break;

								// 开启隧道,先判断有无隧道,有则创建服务端改变隧道信息.

								case "open":

									String id = datas[1];

									if (NAT_INFOS.containsKey(id)) {

										// 如果已经在线则提示ok,否则创建指定隧道类并启动.

										NATInfo info = NAT_INFOS.get(id);

										StringBuilder b = new StringBuilder();

										b.append("ok;"); b.append(info.getIp()); b.append(';'); b.append(info.getPort());

										b.append(';'); b.append(info.getServerPort()); b.append(';'); b.append(info.getProtocol());

										if (info.getState() == NATState.在线) {

											output.write(b.toString().getBytes()); output.flush();

											Log.printAlarm("TCP接收器开启隧道,隧道已经是开启的,客户请求 ip: " + requestIp);

										} else {

											// 通过配置文件获取到指定协议类,如果没有则出错

											// 这里最好是将用户拉黑... 因为一般都是同过不正当渠道...

											String pClass = ConfigurationFactory.getConfig("protocol").getProperty(info.getProtocol());

											if (pClass == null) { Log.printAlarm("TCP接收器开启隧道,没有指定协议！协议为: " + info.getProtocol() + ",客户请求 ip: " + requestIp); return; }

											try {

												ServerProtocol server = (ServerProtocol) Class.forName(pClass).getConstructor().newInstance();

												// 设置隧道服务器

												info.setServer(server);

												output.write(b.toString().getBytes()); output.flush();

												server.start(info);

											} catch (ClassNotFoundException e) { Log.printErr("TCP接收器开启隧道,类找不到: " + pClass + ",客户请求 ip: " + requestIp);

											} catch (Exception e) { Log.printErr("TCP接收器开启隧道,出大问题了!!!客户请求 ip: " + requestIp + "\n错误信息: " + e.getMessage()); }

										}

									} else {

										output.write("error;没有此id".getBytes()); output.flush();

										Log.printAlarm("TCP接收器开启隧道没有此id,客户请求 ip: " + requestIp);

									}

									break;

								// 关闭隧道,无任何返回.执行完后调用一次 GC.

								case "close":

									id = datas[1];

									if (NAT_INFOS.containsKey(id)) {

										NATInfo info = NAT_INFOS.get(id);

										if (info.getState() == NATState.离线) { Log.printAlarm("TCP接收器关闭隧道已经是关闭的,客户请求 ip: " + requestIp); }

										else if (info.getServer() == null) { Log.printAlarm("TCP接收器关闭隧道没有此id,客户请求 ip: " + requestIp); }

										else { info.getServer().stop(); info.setServer(null); }

									} else { Log.printAlarm("TCP接收器关闭隧道没有此id,客户请求 ip: " + requestIp); }

									System.gc();

									break;

								default: Log.printAlarm("TCP 接收器接收到不合法数据: " + new String(data));

								}

							}

						}

					} catch (IOException e) {

						e.printStackTrace();

						Log.printErr("接收到数据,执行解析操作失败: " + e.getMessage());

					} finally {

						try {

							if (socket != null)	socket.close();

						} catch (IOException e) { Log.printErr("Socket关闭失败: " + e.getMessage()); }

					}

				}).start();

			} catch (IOException e) { Log.printErr("接收到数据,获取Socket失败: " + e.getMessage()); }

		}

	}

	public static void main(String[] args) throws UnknownHostException, IOException {

		Socket socket = new Socket("127.0.0.1",9999);

		BufferedOutputStream output = new BufferedOutputStream(socket.getOutputStream());

		BufferedInputStream input = new BufferedInputStream(socket.getInputStream());

		byte[] b = new byte[1024];

		// 添加

		output.write("add;8888;10000;tcp".getBytes());

		output.flush();

		// 获取到隧道id

		int len = input.read(b);

		String addReceive = new String(b,0,len);

		String id = addReceive.split(";")[1];

		System.out.println(addReceive);

		// 将之前的关闭,因为一个请求只能做一次操作

		output.close();

		input.close();

		socket.close();

		socket = new Socket("127.0.0.1",9999);

		output = new BufferedOutputStream(socket.getOutputStream());

		input = new BufferedInputStream(socket.getInputStream());

		// 打开

		output.write(("open;"+id).getBytes());

		output.flush();

		len = input.read(b);

		System.out.println(new String(b,0,len));

		socket.close();

		// 将之前的关闭,因为一个请求只能做一次操作

		output.close();

		input.close();

		socket.close();

		socket = new Socket("127.0.0.1",9999);

		output = new BufferedOutputStream(socket.getOutputStream());

		// 关闭

		output.write(("close;"+id).getBytes());

		output.flush();

		output.close();

		socket.close();

	}

}

package shendi.nat.protocol;

import shendi.nat.bean.NATInfo;

public class TCPServer extends ServerProtocol {

	@Override

	protected void onCreate(NATInfo info) {

		// TODO Auto-generated method stub

		System.out.println("创建了");

	}

	@Override

	protected void run() {

		// TODO Auto-generated method stub

		System.out.println("运行了");

	}

	@Override

	protected void onStop() {

		// TODO Auto-generated method stub

		System.out.println("关闭了");

	}

}

	/**

	 * 服务端穿透通信.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param type 类型

	 * @param info 后续数据信息,默认会转化成此对象toString形式,字节数组会做另外处理.

	 * @return 组装成的数据的字节表示形式

	 */

	public static final byte[] serverNAT(String type,Object... info) {

		byte[] data = type.getBytes();

		for (Object obj : info) {

			byte[] temp = data;

			byte[] bytes;

			if (obj instanceof byte[]) {

				bytes = (byte[]) obj;

			} else {

				bytes = obj.toString().getBytes();

			}

			data = new byte[temp.length + bytes.length + 1];

			System.arraycopy(temp, 0, data, 0, temp.length);

			data[temp.length] = ';';

			System.arraycopy(bytes, 0, data, temp.length+1, bytes.length);

		}

		byte[] temp = data;

		data = new byte[temp.length + 2];

		System.arraycopy(temp, 0, data, 0, temp.length);

		data[data.length - 1] = -3;

		data[data.length - 2] = -2;

		return data;

	}

@Override

protected void run() {

	try {

		// 接收请求,将请求转发到客户端(客户端将请求转发到客户服务器).

		Socket socket = server.accept();

		// 新用户连接,

		new Thread(() -> {

			try (BufferedInputStream input = new BufferedInputStream(socket.getInputStream())) {

				// 存储此用户

				sockets.put(userId, socket);

				// 通知客户端有新用户

				cOutput.write(ProtocolUtils.serverNAT("new", userId)); cOutput.flush();

				// 当前id.

				int id = userId;

				// 将用户发送的数据转发给客户端..

				// 一方关闭就会出异常,就直接将socket关闭

				while (true) {

					byte[] data = new byte[0];

					byte[] bytes = new byte[1024];

					int len = -1;

					while ((len = input.read(bytes)) != -1) {

						byte[] temp = data;

						data = new byte[temp.length + len];

						System.arraycopy(temp, 0, data, 0, temp.length);

						System.arraycopy(bytes, 0, data, temp.length, len);

					}

					// 用户将 Socket 关闭了,这里也直接将对应 Socket 关闭

					if (data.length == 0) {

						if (socket != null) socket.close();

						cOutput.write(ProtocolUtils.serverNAT("close", userId)); cOutput.flush();

						cOutput.flush();

						Log.print("用户关闭了连接,用户id: " + userId);

						break;

					}

					cOutput.write(ProtocolUtils.serverNAT("data",id,data));

					cOutput.flush();

				}

			} catch (IOException e) {

				e.printStackTrace();

				Log.printErr("客户端关闭了连接/用户处理出错: " + e.getMessage());

			}

			userId++;

		}).start();

	} catch (IOException e) { Log.printErr("与用户打开连接出错: " + e.getMessage()); }

}

@Override

protected void onStop() {

	try { if (cInput != null) cInput.close(); } catch (IOException e) { Log.printErr("TCP协议类onStop 关闭input出错: " + e.getMessage()); }

	try { if (cOutput != null) cOutput.close(); } catch (IOException e) { Log.printErr("TCP协议类onStop 关闭output出错: " + e.getMessage()); }

	try { if (client != null) client.close(); } catch (IOException e) { Log.printErr("TCP协议类onStop 关闭client出错: " + e.getMessage()); }

	try { if (server != null) server.close(); } catch (IOException e) { Log.printErr("TCP协议类onStop 关闭server出错: " + e.getMessage()); }

}

	public static void main(String[] args) throws UnknownHostException, IOException {

		Socket socket = new Socket("127.0.0.1",9999);

		BufferedOutputStream output = new BufferedOutputStream(socket.getOutputStream());

		BufferedInputStream input = new BufferedInputStream(socket.getInputStream());

		byte[] b = new byte[1024];

		// 添加

		output.write("add;8888;10000;tcp".getBytes());

		output.flush();

		// 获取到隧道id

		int len = input.read(b);

		String addReceive = new String(b,0,len);

		String id = addReceive.split(";")[1];

		System.out.println(addReceive);

		// 将之前的关闭,因为一个请求只能做一次操作

		output.close();

		input.close();

		socket.close();

		socket = new Socket("127.0.0.1",9999);

		output = new BufferedOutputStream(socket.getOutputStream());

		input = new BufferedInputStream(socket.getInputStream());

		// 打开

		output.write(("open;"+id).getBytes());

		output.flush();

		len = input.read(b);

		System.out.println(new String(b,0,len));

		socket.close();

		// 将之前的关闭,因为一个请求只能做一次操作

		output.close();

		input.close();

		socket.close();

		/*

		socket = new Socket("127.0.0.1",9999);

		output = new BufferedOutputStream(socket.getOutputStream());

		// 关闭

		output.write(("close;"+id).getBytes());

		output.flush();

		output.close();

		socket.close();

		*/

		// 测试 服务端 客户端 用户访问

		// 8888是内网端口,我们要打开, 然后通过 10000 来访问到8888

		// 这里是等于创建 内网的服务端

		ServerSocket server = new ServerSocket(8888);

		new Thread(() -> {

			try (Socket s = server.accept();

					OutputStream sOutput = s.getOutputStream()) {

				// 服务端发送的数据不用什么协议

				sOutput.write("我是内网的服务器,hello, world".getBytes());

				sOutput.flush();

				InputStream sInput = s.getInputStream();

				byte[] sByte = new byte[1024];

				int sLen = sInput.read(sByte);

				System.out.println("内网服务端接收到数据: " + new String(sByte,0,sLen));

				server.close();

			} catch (IOException e) {

				e.printStackTrace();

			}

		}).start();

		// 客户端

		// 10000端口是打开的服务端,我们这里创建连接 当做客户端

		// 可以通过打开的时候获取到端口和ip

		socket = new Socket("127.0.0.1", 10000);

		input = new BufferedInputStream(socket.getInputStream());

		output = new BufferedOutputStream(socket.getOutputStream());

		// 用户端 开启后发送数据

		new Thread(() -> {

			try {

				Socket userSocket = new Socket("127.0.0.1", 10000);

				// 接收数据,开启后就创建了连接,连接被创建就会收到服务端发来的数据

				InputStream userInput = userSocket.getInputStream();

				byte[] userByte = new byte[1024];

				int userLen = userInput.read(userByte);

				System.out.println("用户接收到数据: " + new String(userByte,0,userLen));

				OutputStream userOutput = userSocket.getOutputStream();

				userOutput.write("我是用户,hello, world".getBytes());

				userOutput.flush();

				userSocket.close();

			} catch (IOException e) {

				e.printStackTrace();

			}

		}).start();

		// 处理客户端的接收操作

		b = new byte[1024];

		len = input.read(b);

		System.out.println("客户端接收到数据(新用户来了): " + new String(b,0,len));

		// 上面这个数据应该是创建的数据格式,我们创建一个新Socket与内网服务端连接

		// new;id,id应该为0,第一个用户

		Socket serverUserSocket = new Socket("127.0.0.1",8888);

		InputStream serverUserInput = serverUserSocket.getInputStream();

		b = new byte[1024];

		len = serverUserInput.read(b);

		// 接收到内网服务端发的数据直接发给服务端->服务端发给用户]

		System.out.println("客户端接收到内网服务端数据,并发送给服务端: " + new String(b,0,len));

		output.write(ProtocolUtils.serverNAT("data", 0,new String(b,0,len)));

		output.flush();

		// 接收用户->服务端发来的数据

		// 这里粘包了,没有问题,我们写客户端的时候会进行处理.

		b = new byte[1024];

		len = input.read(b);

		String userData = new String(b,0,len);

		System.out.println("客户端接收到数据,并发给内网服务端: " + userData);

		OutputStream serverUserOutput = serverUserSocket.getOutputStream();

		{

			byte[] bytes = userData.split(";")[2].getBytes();

			serverUserOutput.write(new String(bytes,0,bytes.length - 2).getBytes());

		}

		serverUserOutput.close();

		serverUserInput.close();

		serverUserSocket.close();

//		while(true);

		output.close();

		input.close();

		socket.close();

	}

package shendi.nat.client.bean;

import shendi.nat.client.protocol.ClientProtocol;

import shendi.nat.client.view.View;

/**

 * 穿透信息,包含需要访问的ip和端口,状态等.

 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

 * @version 1.0

 */

public class NATInfo {

	/**

	 * 单例模式

	 */

	private NATInfo() {}

	private static final NATInfo INFO = new NATInfo();

	/**

	 * 内网电脑的 ip.

	 */

	private String ip;

	/**

	 * 内网电脑的端口.

	 */

	private int port;

	/**

	 * 服务端对应的端口(经济原因,这里应是域名)

	 */

	private int serverPort;

	/**

	 * 使用的什么协议.

	 */

	private String protocol;

	/**

	 * 当前穿透(隧道)状态.

	 */

	private NATState state = NATState.离线;

	/**

	 * 协议对应的客户类.

	 */

	private ClientProtocol client;

	/**

	 * 当前视图

	 */

	private View view;

	/**

	 * 获取此类的单例对象.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @return {@link NATInfo}

	 */

	public static NATInfo getInfo() { return INFO; }

	/**

	 * 打开隧道的时候获取的信息.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param ip 内网ip

	 * @param port 内网服务端口

	 * @param serverPort 服务器端口

	 * @param protocol 通信协议

	 */

	public void open(String ip,int port,int serverPort,String protocol) {

		this.ip = ip;

		this.port = port;

		this.serverPort = serverPort;

		this.protocol = protocol;

		state = NATState.在线;

	}

	public String getIp() { return ip; }

	public int getPort() { return port; }

	public int getServerPort() { return serverPort; }

	public String getProtocol() { return protocol; }

	public NATState getState() { return state; }

	public void setState(NATState state) { this.state = state; }

	public ClientProtocol getClient() { return client; }

	public void setClient(ClientProtocol client) { this.client = client;}

	public View getView() { return view; }

	public void setView(View view) { this.view = view; }

}

/**

 * 隧道协议抽象类,继承此类来创建一个隧道协议.<br>

 * 创建的隧道协议需要在 protocol.properties 中进行配置.<br>

 * 配置形式为 协议名=类全路径.<br>

 * 如果要实现构造方法,请确保线程安全,请勿执行耗时操作.

 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

 * @version 1.0

 */

public abstract class ClientProtocol {

	/**

	 * 死循环的标志位,true运行,false关闭.

	 */

	private boolean state = true;

	/**

	 * 开启此协议.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param id 隧道id.

	 */

	public final void start(String id) {

		NATInfo.getInfo().setState(NATState.在线);

		new Thread(() ->{

			onCreate(id);

			while (state) { run(); }

			onStop(id);

		}).start();

	}

	/**

	 * 关闭此协议,关闭后就代表此对象将被清理.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 */

	public final void stop() { NATInfo.getInfo().setState(NATState.离线); state = false; }

	/**

	 * 在被创建的时候调用.<br>

	 * 用于打开隧道和初始化.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 */

	protected abstract void onCreate();

	/**

	 * 执行具体操作逻辑.<br>

	 * 此方法会被持续调用,请确保线程安全.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 */

	protected abstract void run();

	/**

	 * 被关闭时调用.<br>

	 * 用于关闭隧道,关闭连接,恢复状态等.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 */

	protected abstract void onStop(String id);

	/**

	 * 创建对应协议的客户端.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param protocol 客户端使用的协议.

	 * @return {@link ClientCodeException}

	 * @throws Exception 反射出异常时抛出.

	 */

	public static ClientProtocol create(String protocol) throws Exception {

		return ((ClientProtocol)Class.forName(ConfigurationFactory.getConfig("protocol").getProperty(protocol)).getConstructor().newInstance());

	}

}

/**

 * 协议工具类,通过此类轻松组装数据.

 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

 * @version 1.0

 */

public class ProtocolUtils {

	/**

	 * 服务端穿透通信.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param type 类型

	 * @param info 后续数据信息,默认会转化成此对象toString形式,字节数组会做另外处理.

	 * @return 组装成的数据的字节表示形式

	 */

	public static final byte[] serverNAT(String type,Object... info) {

		byte[] data = type.getBytes();

		for (Object obj : info) {

			byte[] temp = data;

			byte[] bytes;

			if (obj instanceof byte[]) {

				bytes = (byte[]) obj;

			} else {

				bytes = obj.toString().getBytes();

			}

			data = new byte[temp.length + bytes.length + 1];

			System.arraycopy(temp, 0, data, 0, temp.length);

			data[temp.length] = ';';

			System.arraycopy(bytes, 0, data, temp.length+1, bytes.length);

		}

		byte[] temp = data;

		data = new byte[temp.length + 2];

		System.arraycopy(temp, 0, data, 0, temp.length);

		data[data.length - 1] = -3;

		data[data.length - 2] = -2;

		return data;

	}

	/**

	 * 打开隧道的协议组装.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param id 隧道id

	 * @return 组装后的数据

	 */

	public static final byte[] open(String id) {

		byte[] typeData = "open;".getBytes();

		byte[] idData = id.getBytes();

		byte[] data = new byte[typeData.length + idData.length];

		System.arraycopy(typeData, 0, data, 0, typeData.length);

		System.arraycopy(idData, 0, data, typeData.length, idData.length);

		return data;

	}

	/**

	 * 关闭隧道的协议组装.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param id 隧道id

	 * @return 组装后的数据

	 */

	public static final byte[] close(String id) {

		byte[] typeData = "close;".getBytes();

		byte[] idData = id.getBytes();

		byte[] data = new byte[typeData.length + idData.length];

		System.arraycopy(typeData, 0, data, 0, typeData.length);

		System.arraycopy(idData, 0, data, typeData.length, idData.length);

		return data;

	}

	/**

	 * 解析开启隧道操作返回的数据.

	 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

	 * @param data 数据

	 * @return 操作是否成功.

	 */

	public static final boolean analysisOpen(String data) {

		String[] datas = data.split(";");

		// 一层层获取

		if (datas.length > 0) {

			String status = datas[0];

			if ("ok".equals(status)) {

				if (datas.length > 4) {

					NATInfo.getInfo().open(datas[1], Integer.parseInt(datas[2]), Integer.parseInt(datas[3]), datas[4]);

					return true;

				} else {

					NATInfo.getInfo().getView().sendInfo("开启隧道失败,网络不佳,请重试");

					Log.printAlarm("开启隧道失败,数据不完整: " + data);

					return false;

				}

			} else if ("error".equals(status)) {

				NATInfo.getInfo().getView().sendInfo(datas[1]);

				Log.print("开启隧道失败,信息为: " + datas[1]);

			} else {

				NATInfo.getInfo().getView().sendInfo("开启隧道失败,协议错误.");

				Log.printAlarm("开启隧道失败,数据协议错误: " + data);

			}

		}

		return false;

	}

}

/**

 * 使用 TCP 协议的控制器,

 * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>

 * @version 1.0

 */

public class TCPController extends Controller {

	@Override

	public boolean open(String id) {

		String[] url = ConfigurationFactory.getConfig("config").getProperty("server.url").split(":");

		try (Socket socket = new Socket(url[0],Integer.parseInt(url[1]));

				InputStream input = socket.getInputStream();

				OutputStream output = socket.getOutputStream()) {

			output.write(ProtocolUtils.open(id));

			output.flush();

			// 接收服务端传来的数据并解析.

			byte[] data = new byte[0];

			byte[] bytes = new byte[1024];

			int len = -1;

			while ((len = input.read(bytes)) != -1) {

				byte[] temp = data;

				data = new byte[temp.length + len];

				System.arraycopy(temp, 0, data, 0, temp.length);

				System.arraycopy(bytes, 0, data, temp.length, len);

			}

			// 解析数据成功则打开与指定服务端的连接

			if (ProtocolUtils.analysisOpen(new String(data))) {

				try {

					ClientProtocol.create(NATInfo.getInfo().getProtocol()).start(id);

                                        return true;

				} catch (Exception e) {

					Log.printErr("打开隧道,创建客户端错误,请重新打开: " + e.getMessage());

					NATInfo.getInfo().getView().sendInfo("打开隧道,创建客户端错误,请重新打开: " + e.getMessage());

				}

			}

		} catch (IOException e) {

			Log.printErr("打开隧道错误: " + e.getMessage());

			NATInfo.getInfo().getView().sendInfo("打开隧道错误: " + e.getMessage());

		}

		return false;

	}

	@Override

	public void close(String id) {

		String[] url = ConfigurationFactory.getConfig("config").getProperty("server.url").split(":");

		try (Socket socket = new Socket(url[0],Integer.parseInt(url[1]));

				OutputStream output = socket.getOutputStream()) {

			output.write(ProtocolUtils.close(id));

			output.flush();

		} catch (IOException e) {

			e.printStackTrace();

			Log.printErr("关闭隧道错误: " + e.getMessage());

			NATInfo.getInfo().getView().sendInfo("关闭隧道错误: " + e.getMessage());

		}

	}

}

@Override

public void show() {

	while (true) {

		// 通过现在隧道状态来分界面

		String input;

		// 隧道在线

		if (NATState.在线 == NATInfo.getInfo().getState()) {

			sendInfo("* * * * * * 隧道在线 * * * * * *");

			sendInfo("exit\t\t退出");

			sendInfo("* * * * * * * * * * * * * * * *");

			input = sc.nextLine();

			// 过滤掉空字符

			while ("".equals(input)) input = sc.nextLine();

			String[] data = input.split(" ");

			switch (data[0]) {

			case "exit":

				System.exit(0);

				break;

			}

		// 隧道离线

		} else if (NATState.离线 == NATInfo.getInfo().getState()) {

			sendInfo("* * * * * * 隧道离线 * * * * * *");

			sendInfo("open [隧道id]\t打开隧道");

			sendInfo("exit\t\t退出");

			sendInfo("* * * * * * * * * * * * * * * *");

			input = sc.nextLine();

			// 过滤掉空字符

			while ("".equals(input)) input = sc.nextLine();

			String[] data = input.split(" ");

			switch (data[0]) {

			case "open":

				if (data.length > 1 && !"".equals(data[1])) {

					try {

						if (!Controller.create().open(data[1])) {

							String info = "隧道 [" + data[1] + "] 打开失败";

							Log.printErr(info);

							NATInfo.getInfo().getView().sendInfo(info);

						}

					} catch (Exception e) {

						e.printStackTrace();

					}

				} else { System.out.println("使用open命令的方法为: open 隧道id"); }

				break;

			case "exit":

				System.exit(0);

				break;

			}

		} else {

			System.err.println("控制台出现未知错误!");

			// 等待用户输入后退出

			try {

				Runtime.getRuntime().exec("cmd /c pause");

			} catch (IOException e) {

				e.printStackTrace();

			}

			System.exit(0);

		}

	}

}