public void StartListening()
{
int port = Server.ServerSettings.Port;
if (!NetUtils.PortAvailability(port))
{
ConsoleFunctions.WriteErrorLine("Port already in use... Shutting down server... [{0}]", port);
Server.StopServer();
return;
}
ConsoleFunctions.WriteInfoLine("Starting server on port... {0}", port);
_serverListener = new TcpListener(IPAddress.Any, port);
if (_serverListener == null)
{
ConsoleFunctions.WriteErrorLine("An error occured when starting the client listener.. Null TCPListener..");
return;
}
_serverListener.Start();
ConsoleFunctions.WriteInfoLine("Ready & looking for client connections... ");
ConsoleFunctions.WriteInfoLine("To shutdown the server safely press CTRL+C or use stop/shutdown!");
while (_serverListener.Server.IsBound)
{
TcpClient client = _serverListener.AcceptTcpClient();
ConsoleFunctions.WriteDebugLine("A new client has been accepted.");
new Task(() =>
{
HandleClientConnection(client);
}).Start();
}
}
public AnvilLevel(string worldname)
{
Difficulty = 0;
LvlName = worldname;
LevelType = LvlType.Default;
Generator = new AnvilWorldProvider(worldname);
ConsoleFunctions.WriteDebugLine("Level Type: Anvil");
}
public NetherLevel(string worldname)
{
Difficulty = 0;
LvlName = worldname;
LevelType = LvlType.Default;
Generator = new NetherWorldProvider(worldname);
ConsoleFunctions.WriteDebugLine("Level Type: Nether");
Dimension = -1;
}
public StandardLevel(string worldname)
{
Difficulty = 0;
LvlName = worldname;
LevelType = LvlType.Default;
Generator = new StandardWorldProvider(worldname);
ConsoleFunctions.WriteDebugLine("Level Type: Standard");
DefaultGamemode = Gamemode.Creative;
}
internal void LoadPlugins()
{
if (Config.GetProperty("PluginDisabled", false))
{
return;
}
var pluginDirectory = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);
pluginDirectory = Config.GetProperty("PluginDirectory", pluginDirectory);
if (pluginDirectory != null)
{
pluginDirectory = Path.GetFullPath(pluginDirectory);
foreach (var pluginPath in Directory.GetFiles(pluginDirectory, "*.dll", SearchOption.AllDirectories))
{
var newAssembly = Assembly.LoadFile(pluginPath);
var types = newAssembly.GetExportedTypes();
foreach (var type in types)
{
try
{
if (!type.IsDefined(typeof(PluginAttribute), true) && !typeof(IPlugin).IsAssignableFrom(type))
{
continue;
}
if (type.IsDefined(typeof(PluginAttribute), true))
{
var pluginAttribute = Attribute.GetCustomAttribute(type, typeof(PluginAttribute), true) as PluginAttribute;
if (pluginAttribute != null)
{
if (!Config.GetProperty(pluginAttribute.PluginName + ".Enabled", true))
{
continue;
}
}
}
var ctor = type.GetConstructor(Type.EmptyTypes);
if (ctor != null)
{
var plugin = ctor.Invoke(null);
_plugins.Add(plugin);
LoadCommands(type);
LoadOnPlayerJoin(type);
}
}
catch (Exception ex)
{
ConsoleFunctions.WriteWarningLine("Failed loading plugin type " + type + " as a plugin.");
ConsoleFunctions.WriteDebugLine("Plugin loader caught exception: " + ex);
}
}
}
}
}
private void HandleClientCommNew(object client)
{
TcpClient tcpClient = (TcpClient)client;
NetworkStream clientStream = tcpClient.GetStream();
ClientWrapper Client = new ClientWrapper(tcpClient);
//Buffer size of 4096 Bytes, reason: I guess we don't need more?
byte[] message = new byte[4096];
int bytesRead;
while (true)
{
bytesRead = 0;
try
{
//if (clientStream.DataAvailable)
bytesRead = clientStream.Read(message, 0, 4096);
if (bytesRead > 0)
{
ConsoleFunctions.WriteDebugLine("Packet received. Time: " + DateTime.Now.ToLocalTime());
ConsoleFunctions.WriteDebugLine("Packet ID: " + Globals.v2Int32(message, 1)[0]);
PacketHandler.PacketHandler PH = new PacketHandler.PacketHandler();
Thread handler = new Thread(() => PH.HandlePacket(Client, message));
handler.Start();
}
if (bytesRead == 0)
{
//Close connection with user. as he disconnected!
break;
}
}
catch (Exception ex)
{
ConsoleFunctions.WriteErrorLine("ERROR! \n" + ex.Message);
break;
}
}
ConsoleFunctions.WriteDebugLine("A client disconnected!");
if (Utils.PlayerHelper.isConnectedPlayer(Client))
{
ConsoleFunctions.WriteInfoLine("Player '" + Utils.PlayerHelper.getPlayer(Client).Username + "' disconnected!");
Client._Player.SaveToFile();
Globals.Players.Remove(Utils.PlayerHelper.getPlayer(Client));
Globals.PlayerOnline--;
Globals.updateTitle();
}
tcpClient.Close();
Globals.ActiveConnections--;
Globals.updateTitle();
}
public void ListenForClients()
{
Globals._ServerListener.Start();
ConsoleFunctions.WriteServerLine("Ready for connections...");
while (true)
{
TcpClient client = Globals._ServerListener.AcceptTcpClient();
ConsoleFunctions.WriteDebugLine("A new connection has been made!");
Globals.ActiveConnections++;
Globals.updateTitle();
Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClientCommNew));
clientThread.Start(client);
}
}
public void HandlePacket(object Client, byte[] Data)
{
ClientWrapper cWrapper = (ClientWrapper)Client;
int[] _INT = Globals.v2Int32(Data, 0);
int PacketSize = _INT[0];
int NextData = _INT[1];
ConsoleFunctions.WriteDebugLine("Packetsize: " + PacketSize.ToString() + " Next data: " + NextData.ToString());
int PacketID = Globals.v2Int32(Data, NextData)[0];
switch (PacketID)
{
case 0x00:
new Handshake().Handle(cWrapper, Data);
break;
case 0x01:
if (PacketSize == 9)
{
new Ping().Handle(cWrapper, Data);
}
else
{
new SharpMC.Networking.PacketHandler.Packets.Ingoing.ChatMessage().Handle(cWrapper, Data);
}
break;
case 0x04:
new PlayerPosition().Handle(cWrapper, Data);
break;
case 0x06:
new PlayerPositionAndLook().Handle(cWrapper, Data);
break;
case 0x03:
new SharpMC.Networking.PacketHandler.Packets.Ingoing.PlayerOnGround().Handle(cWrapper, Data);
break;
case 0x05:
new SharpMC.Networking.PacketHandler.Packets.Ingoing.PlayerLook().Handle(cWrapper, Data);
break;
default:
ConsoleFunctions.WriteWarningLine("Unknown packet received! ('" + PacketID + "')");
break;
}
}
public dynamic GetProperty(string property, dynamic defaultValue)
{
foreach (string line in File.ReadAllLines(ConfigName))
{
string[] split = line.Split('=');
if (split.Length >= 2)
{
if (!String.IsNullOrEmpty(split[0]) && split[0].Equals(property, StringComparison.InvariantCultureIgnoreCase))
{
return(TypeDescriptor.GetConverter(defaultValue.GetType()).ConvertFromString(split[1]));
}
}
}
ConsoleFunctions.WriteDebugLine("Property value couldn't be found (Property: {0}, Value: {1})", true, property, defaultValue);
return(defaultValue);
}
public static int ReadVarInt(NetworkStream stream)
{
var value = 0;
var size = 0;
int b;
while (((b = stream.ReadByte()) & 0x80) == 0x80)
{
value |= (b & 0x7F) << (size++ *7);
if (size > 5)
{
ConsoleFunctions.WriteDebugLine("VarInt size is longer than expected. (Size: {0})", size);
//throw new IOException("VarInt size is longer than expected. (Size: {0})", size);
}
}
return(value | ((b & 0x7F) << (size * 7)));
}
public void ListenForClients()
{
var port = Config.GetProperty("port", 25565);
if (port != 25565)
{
_serverListener = new TcpListener(IPAddress.Any, port);
}
_serverListener.Start();
_listening = true;
ConsoleFunctions.WriteServerLine("Ready for connections...");
ConsoleFunctions.WriteInfoLine("To shutdown the server safely press CTRL+C");
while (_listening)
{
var client = _serverListener.AcceptTcpClient();
ConsoleFunctions.WriteDebugLine("A new connection has been made!");
new Task((() => { HandleClientCommNew(client); })).Start(); //Task instead of Thread
}
}
public CraftingRecipe(ItemStack result, object[] recipe)
{
resultItem = result;
for (var i = 0; i < 3; i++)
{
if (recipe[i] is string)
{
_recipe[i] = (string)recipe[i];
}
else
{
throw new InvalidDataException("recipe invalid");
}
}
var prevchar = ' ';
for (var i = 4; i < recipe.Length; i++) //Load dictionairy
{
var val = recipe[i];
if (val is char)
{
var d = (char)val;
prevchar = d;
}
if (val is ItemStack)
{
var d = (ItemStack)val;
if (prevchar != ' ')
{
recipeDictionary.Add(prevchar, d);
prevchar = ' ';
}
}
}
ConsoleFunctions.WriteDebugLine("Added crafting recipe for item id: " + result.ItemId);
}
public static void SendResponse(ClientWrapper tcpClient, byte[] Data)
{
// List<byte> actData = new List<byte>(Data[0] + 1);
// for (int i = 0; i < (Data[0] + 1); i++)
//{
// actData.Add(Data[i]);
// }
try
{
tcpClient.Client.NoDelay = false;
NetworkStream clientStream = tcpClient.Client.GetStream();
clientStream.Write(Data, 0, Data.Length);
clientStream.Flush();
}
catch (Exception ex)
{
ConsoleFunctions.WriteErrorLine("F**K, We failed to send a packet... The following error occured: " + ex.Message);
}
ConsoleFunctions.WriteDebugLine("Packet send with Packet ID: " + Data[1]);
ConsoleFunctions.WriteDebugLine("Packet send with Packet Length: " + Data[0]);
ConsoleFunctions.WriteDebugLine("Actual packet length: " + Data.Length);
}
public override void Handle(ClientWrapper Client, byte[] Data)
{
ClientWrapper tcpClient = Client;
/*
* I know Host and ActualPort are currently not used.
* I will use them to verify people are not using a proxy later on.
*/
int[] _Hostdata = Globals.v2Int32(Data, 3);
int HostLength = _Hostdata[0];
int NextData = _Hostdata[1];
string Host = Encoding.UTF8.GetString(Data, NextData, HostLength);
ushort actualPort;
if (BitConverter.IsLittleEndian)
{
actualPort = BitConverter.ToUInt16(new byte[2] {
(byte)Data[14], (byte)Data[13]
}, 0);
}
else
{
actualPort = BitConverter.ToUInt16(new byte[2] {
(byte)Data[13], (byte)Data[14]
}, 0);
}
try
{
/*
* We get the Handshake state here.
* This way we know what we need to handle.
* If the handshake state is 1 then we know we have to handle a status request.
* If the handshake state is 2 then we know we have to handle a login request.
*/
int HandShakeState = Globals.v2Int32(Data, 15)[0];
if (HandShakeState == 1)
{
ConsoleFunctions.WriteDebugLine("Handling Status Request!");
StatusResponse(tcpClient, Data);
}
else if (HandShakeState == 2)
{
ConsoleFunctions.WriteDebugLine("Handling Login Request!");
LoginRequest(tcpClient, Data);
}
else
{
ConsoleFunctions.WriteDebugLine("We received an unknown Handshake state! WTF \nStopping");
return;
}
}
catch (Exception ex)
{
/*
* Seems we have an error here.
* That's sad... We log it for debugging purposes.
*/
ConsoleFunctions.WriteDebugLine(ex.ToString());
}
}
public void AddLevel(string name, Level lvl)
{
ConsoleFunctions.WriteDebugLine("Initiating level: " + name);
SubLevels.Add(name, lvl);
}
/*
* TODO: Fix data compression
* TODO: Look into: Internal Exception: io.netty.handler.codec.DecoderException: java.lang.IndexOutOfBoundsException: readerIndex(2) + length(72) exceeds writerIndex(2): UnpooledHeapByteBuf(ridx: 2, widx: 2, cap: 2)
*/
private void HandleClientConnection(TcpClient client)
{
NetworkStream clientStream = client.GetStream();
ClientWrapper WrappedClient = new ClientWrapper(client);
Globals.ClientManager.AddClient(ref WrappedClient);
while (true)
{
try
{
if (Server.ServerSettings.UseCompression && WrappedClient.PacketMode == PacketMode.Play)
{
int packetLength = NetUtils.ReadVarInt(clientStream);
int dataLength = NetUtils.ReadVarInt(clientStream);
int actualDataLength = packetLength - NetUtils.GetVarIntBytes(dataLength).Length;
ConsoleFunctions.WriteInfoLine("PacketLength: {0} \n DataLength: {1} \n ActualDataLength: {2}", packetLength, dataLength, actualDataLength);
if (dataLength == 0)
{
if (!ReadCompressed(WrappedClient, clientStream, actualDataLength))
{
break;
}
}
else
{
if (!ReadUncompressed(WrappedClient, clientStream, dataLength))
{
break;
}
}
}
else
{
if (!ReadUncompressed(WrappedClient, clientStream, NetUtils.ReadVarInt(clientStream)))
{
break;
}
}
}
catch (Exception ex)
{
ConsoleFunctions.WriteDebugLine("Error: \n" + ex);
if (Server.ServerSettings.ReportExceptionsToClient)
{
new Disconnect(WrappedClient)
{
Reason = new ChatText("Server threw an exception!\n\nException: \n" + ex.Message, TextColor.Reset)
}.Write();
}
else
{
new Disconnect(WrappedClient)
{
Reason = new ChatText("You were kicked because of an internal problem!", TextColor.Reset)
}.Write();
}
break;
}
}
Globals.DisconnectClient(WrappedClient);
Thread.CurrentThread.Abort();
}
private bool ExecuteCommand(MethodInfo method, Player player, string[] args, CommandAttribute commandAttribute)
{
var parameters = method.GetParameters();
var addLenght = 0;
int requiredParameters = 0;
if (parameters.Length > 0 && parameters[0].ParameterType == typeof(Player))
{
addLenght = 1;
requiredParameters = -1;
}
bool hasRequiredParameters = true;
bool hasStringArray = false;
foreach (var param in parameters)
{
if (!param.IsOptional)
{
requiredParameters++;
}
if (param.ParameterType == typeof(string[]))
{
hasStringArray = true;
}
}
if (args.Length < requiredParameters && !hasStringArray)
{
hasRequiredParameters = false;
}
if (!hasRequiredParameters || args.Length > (parameters.Length - addLenght) && !hasStringArray)
{
player.SendChat("Invalid command usage!", ChatColor.Red);
player.SendChat(commandAttribute.Usage, ChatColor.Red);
return(true);
}
var objectArgs = new object[parameters.Length];
bool stringarrayfound = false;
int stringarrayposition = 0;
List <string> stringarrayvalues = new List <string>();
int length = args.Length + addLenght;
for (var k = 0; k < length; k++)
{
var parameter = parameters[k];
var i = k - addLenght;
if (k == 0 && addLenght == 1)
{
if (parameter.ParameterType == typeof(Player))
{
objectArgs[k] = player;
continue;
}
ConsoleFunctions.WriteWarningLine("Command method " + method.Name + " missing Player as first argument.");
return(false);
}
if (parameter.ParameterType == typeof(string[]))
{
stringarrayfound = true;
stringarrayposition = k;
stringarrayvalues.Add(args[i]);
objectArgs[stringarrayposition] = stringarrayvalues.ToArray();
break;
}
if (parameter.ParameterType == typeof(string))
{
objectArgs[k] = args[i];
continue;
}
if (parameter.ParameterType == typeof(byte))
{
byte value;
if (!byte.TryParse(args[i], out value))
{
return(false);
}
objectArgs[k] = value;
continue;
}
if (parameter.ParameterType == typeof(short))
{
short value;
if (!short.TryParse(args[i], out value))
{
return(false);
}
objectArgs[k] = value;
continue;
}
if (parameter.ParameterType == typeof(int))
{
int value;
if (!int.TryParse(args[i], out value))
{
return(false);
}
objectArgs[k] = value;
continue;
}
if (parameter.ParameterType == typeof(bool))
{
bool value;
if (!bool.TryParse(args[i], out value))
{
return(false);
}
objectArgs[k] = value;
continue;
}
if (parameter.ParameterType == typeof(float))
{
float value;
if (!float.TryParse(args[i], out value))
{
return(false);
}
objectArgs[k] = value;
continue;
}
if (parameter.ParameterType == typeof(double))
{
double value;
if (!double.TryParse(args[i], out value))
{
return(false);
}
objectArgs[k] = value;
continue;
}
if (parameter.ParameterType == typeof(Player))
{
Player value = Globals.LevelManager.GetAllPlayers().FirstOrDefault(p => p.Username.ToLower().Equals(args[i].ToLower()));
if (value == null)
{
player.SendChat(String.Format("Player \"{0}\" is not found!", args[i]), ChatColor.Red);
return(true);
}
objectArgs[k] = value;
continue;
}
return(false);
}
if (stringarrayfound)
{
for (int k = stringarrayposition + 1; k <= args.Length; k++)
{
var i = k - addLenght;
stringarrayvalues.Add(args[i]);
objectArgs[stringarrayposition] = stringarrayvalues.ToArray();
}
}
var pluginInstance = _plugins.FirstOrDefault(plugin => plugin.GetType() == method.DeclaringType);
if (pluginInstance == null)
{
ConsoleFunctions.WriteDebugLine("Plugin instance is null!");
return(false);
}
if (method.IsStatic)
{
method.Invoke(null, objectArgs);
}
else
{
if (method.DeclaringType == null)
{
return(false);
}
method.Invoke(pluginInstance, objectArgs);
}
return(true);
}
private void HandleClientCommNew(object client)
{
var tcpClient = (TcpClient)client;
var clientStream = tcpClient.GetStream();
var Client = new ClientWrapper(tcpClient);
Globals.ClientManager.AddClient(ref Client);
while (true)
{
try
{
while (!clientStream.DataAvailable)
{
if (Client.Kicked)
{
break;
}
Thread.Sleep(5);
}
if (Client.Kicked)
{
break;
}
if (ServerSettings.UseCompression && Client.PacketMode == PacketMode.Play)
{
int packetLength = ReadVarInt(clientStream);
int dataLength = ReadVarInt(clientStream);
int actualDataLength = packetLength - GetVarIntBytes(dataLength).Length;
if (dataLength == 0)
{
if (!ReadCompressed(Client, clientStream, actualDataLength))
{
break;
}
}
else
{
if (!ReadUncompressed(Client, clientStream, dataLength))
{
break;
}
}
}
else
{
int dlength = ReadVarInt(clientStream);
if (!ReadUncompressed(Client, clientStream, dlength))
{
break;
}
}
}
catch (Exception ex)
{
//Exception, disconnect!
ConsoleFunctions.WriteDebugLine("Error: \n" + ex);
if (ServerSettings.ReportExceptionsToClient)
{
new Disconnect(Client)
{
Reason = new McChatMessage("§fServer threw an exception!\n\nFor the nerdy people: \n" + ex.Message)
}.Write();
}
else
{
new Disconnect(Client)
{
Reason = new McChatMessage("§fYou were kicked because of an unknown problem!")
}.Write();
}
break;
}
}
if (Client.Kicked)
{
new Disconnect(Client)
{
Reason = new McChatMessage("§fYou were kicked because of a network problem!")
}.Write();
}
//Close the connection with the client. :)
Client.ThreadPool.KillAllThreads();
//Client.StopKeepAliveTimer();
if (Client.Player != null)
{
Client.Player.SavePlayer();
Client.Player.Level.RemovePlayer(Client.Player.EntityId);
Client.Player.Level.BroadcastPlayerRemoval(Client);
}
Client.TcpClient.Close();
Globals.ClientManager.RemoveClient(Client);
Thread.CurrentThread.Abort();
}
private void LoginRequest(ClientWrapper tcpClient, byte[] Data)
{
/*
* We need to get the username another way than Hardcode it in...
* I don't see where to get it from at the moment tho :S
*/
/*
* Oops this code below was published accidentaly!
* I was checking for a way i can retrieve the username. Still seems bugged tho, really strange.
*/
int[] UsernameStuff = Globals.v2Int32(Data, 3);
int _UsernameLength = UsernameStuff[0];
int NextIndex = UsernameStuff[1];
ConsoleFunctions.WriteDebugLine("Username length: " + _UsernameLength + " | Next index: " + NextIndex);
string uName = Encoding.UTF8.GetString(Data, NextIndex, _UsernameLength);
ConsoleFunctions.WriteDebugLine("Username: "******"kennyvv";
byte[] _Username = Encoding.UTF8.GetBytes(Username);
//We grab the UUID for the Username.
string UUID = Globals.getUUID(Username);
Guid g = new Guid(UUID);
UUID = g.ToString();
byte[] _UUID = Encoding.UTF8.GetBytes(UUID);
byte[] PacketID = Globals.getVarInt(0x02);
byte[] UUIDLength = Globals.getVarInt(_UUID.Length);
Player _Player;
//We create new player data.
//This is the data we can retrieve later on using the PlayerHelper class.
try
{
try
{
_Player = Utils.PlayerHelper.getPlayer(UUID);
}
catch (FileNotFoundException ex)
{
_Player = SharpMC.Utils.PlayerHelper.addPlayer(new Player()
{
Username = Username, UUID = UUID, Gamemode = new Gamemode()
{
_Gamemode = 1
}, Position = new Position()
{
X = 0, Y = 0, Z = 50
}, Client = tcpClient
});
}
_Player.Client = tcpClient;
_Player.SaveToFile();
tcpClient._Player = _Player;
}
catch (NotSupportedException ex)
{
//Seems we already added this user after all. WTF?!
//Then why didn't we find it? :O
}
byte[] UsernameLength = Globals.getVarInt(_Username.Length);
byte[] TotalLength = Globals.getVarInt(PacketID.Length + _UUID.Length + _Username.Length + UUIDLength.Length + UsernameLength.Length);
byte[] Response = Globals.concatBytes(TotalLength, PacketID, UUIDLength, _UUID, UsernameLength, _Username);
Network.SendResponse(tcpClient, Response);
//We send all packets needed for the player to spawn in the game.
//We still need to send the chunks here.
//However our world generation class is currently not done.
CompressionLevel(tcpClient, Data);
PlayResponse(tcpClient, Data);
SpawnPositionResponse(tcpClient, Data);
new Outgoing.PlayerAbilities().Handle(tcpClient, Data);
new Outgoing.PlayerPositionAndLook().Handle(tcpClient, Data);
}
public override void Handle(ClientWrapper Client, byte[] Data)
{
ConsoleFunctions.WriteDebugLine("Handling PING Request!");
Network.SendResponse(Client, Data);
}
private void HandleClientCommNew(object client)
{
var tcpClient = (TcpClient)client;
var clientStream = tcpClient.GetStream();
var Client = new ClientWrapper(tcpClient);
while (true)
{
try
{
var buffie = new byte[4096];
int receivedData;
receivedData = clientStream.Read(buffie, 0, buffie.Length);
if (receivedData > 0)
{
var buf = new MSGBuffer(Client);
if (Client.Decrypter != null)
{
var date = new byte[4096];
Client.Decrypter.TransformBlock(buffie, 0, buffie.Length, date, 0);
buf.BufferedData = date;
}
else
{
buf.BufferedData = buffie;
}
buf.BufferedData = buffie;
var length = buf.ReadVarInt();
buf.Size = length;
var packid = buf.ReadVarInt();
if (!new PackageFactory(Client, buf).Handle(packid))
{
ConsoleFunctions.WriteWarningLine("Unknown packet received! \"0x" + packid.ToString("X2") + "\"");
}
buf.Dispose();
}
else
{
//Stop the while loop. Client disconnected!
break;
}
}
catch (Exception ex)
{
Client.ThreadPool.KillAllThreads();
//Exception, disconnect!
ConsoleFunctions.WriteDebugLine("Error: \n" + ex);
new Disconnect(Client)
{
Reason = "§4SharpMC\n§fServer threw an exception!\n\nFor the nerdy people: \n" + ex.Message
}.Write();
break;
}
}
//Close the connection with the client. :)
Client.ThreadPool.KillAllThreads();
Client.StopKeepAliveTimer();
if (Client.Player != null)
{
Client.Player.Level.RemovePlayer(Client.Player);
Client.Player.Level.BroadcastPlayerRemoval(Client);
}
Client.TcpClient.Close();
Thread.CurrentThread.Abort();
}
