private void button1_Click(object sender, EventArgs e)
{
TcpClient tcpcl; /*tcp Client that will connect to the new server*/
message msg;
try
{
string ip_addr = textBox1.Text.ToString(); /* Get the IP address inserted by the user */
string password = textBox3.Text.ToString(); /* Get the password inserted by the user */
UInt16 port = Convert.ToUInt16(textBox2.Text.ToString()); /* Convert the port string to UInt16 type */
IPAddress ip = IPAddress.Parse(ip_addr); /* Convert the string IP to IPAddress type */
tcpcl = new TcpClient();
tcpcl.Connect(ip, port); /* Here we try to connect with the new Server. */
byte[] data = Encoding.Unicode.GetBytes(password); /* Here we are converting the password to a byte array */
SocketCommunication.sendBufferToSocket(data, tcpcl); /* Then we send the byte array with the password to the server. */
data = SocketCommunication.receiveBufferFromSocket(tcpcl); /* Here we're receiving the server reply, that shows if the password is correct. */
msg = SocketCommunication.rawDeserialize <message>(data); /* Here we deserialize the received buffer. */
if (msg.messType == messageType.CONNECTION_REFUSED) /* If the message contains "Connection Refused", the password is probably wrong. */
{
throw new Exception("Wrong Password");
}
if (msg.messType != messageType.CONNECTION_ACCEPTED) /* The server has to reply with a "CONNECTION_ACCEPTED message" */
{
throw new Exception("Error!");
}
AddS(tcpcl.Client.RemoteEndPoint.ToString(), tcpcl); /* Here we're calling the delegate in order to add the new server to the main window server list. */
this.Close(); /* After the server connection, the window will close "automatically" */
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/*
* Server function. While main thread is waiting for user commands,
* this thread is listening for client connection/commands and eventually will inject events in system queue.
*/
private void listener_function()
{
message msg = new message();
byte[] data; /*Byte array containing received data*/
bool breaker; /*Boolean variable to break out of the inner loop*/
serverSocket.Start(); /*Initialization of server Socket*/
MessageBox.Show("Server Is Listening!");
while (connected)
{
try /* This try/catch block is in the while loop in order to avoid the listener thread termination due to some exception */
{
clientSocket = serverSocket.AcceptTcpClient(); /*The server is waiting for a client connection*/
data = SocketCommunication.receiveBufferFromSocket(clientSocket); /* First thing, the client sends to the server the password */
string psw = Encoding.Unicode.GetString(data); /* Get the password string from the byte array received */
if (psw.CompareTo(password) == 0) /* If the password is correct */
{
msg.messType = messageType.CONNECTION_ACCEPTED; /* The server reply with a "ConnectionAccepted message" */
}
else /* If the password is wrong */
{
msg.messType = messageType.CONNECTION_REFUSED;/* The server reply with a "Connection Refused Message" */
}
SocketCommunication.sendBufferToSocket(SocketCommunication.rawSerialize(msg), clientSocket);
if (msg.messType == messageType.CONNECTION_REFUSED) /* If the password was wrong, we must not accept client messages. */
{
throw new Exception("Wrong Password"); /* Then we have to listen for a new connection, showing to the user the message "Wrong Password" */
}
/*
* Here we are showing to the user info about the client actually connected
*/
Invoke(new editLabel(this.editLabel), new object[] { statusInfo, "CONNECTED WITH " + clientSocket.Client.RemoteEndPoint.ToString() });
this.target = true;
breaker = true; /* While the client is still active, we have to receive client messages. Breaker = false only if the client send to the server a "Disconnect" message */
while (breaker)
{
data = SocketCommunication.receiveBufferFromSocket(clientSocket); /* Wait for a client message */
msg = SocketCommunication.rawDeserialize <message>(data); /* Deserialization of the received byte array */
switch (msg.messType) /* We have to check which message has been received */
{
case messageType.ACTION: /* We received a message whith an input which has to be sent to the system queue */
inputSend(msg.act); /* Function that inject the input in the system */
break;
case messageType.DISCONNECT: /* We received a "Disconnect" message */
this.clientSocket.Close(); /* We have to close the TcpClient on which we are receiving the messages */
this.target = false; /* Obviously this server isn't longer the target! */
Invoke(new editLabel(this.editLabel), new object[] { statusInfo, "DISCONNECTED" }); /* The server status is now "DISCONNECTED" */
Invoke(new editLabel(this.editLabel), new object[] { targetInfo, "FALSE" }); /* And this server is not longer the target */
breaker = false; /* We have to break out from the inner loop in order to accept another client connection. */
break;
case messageType.TARGET_CHANGED: /* This server is not longer the target, but the client is still connected */
this.target = false;
Invoke(new editLabel(this.editLabel), new object[] { targetInfo, "FALSE" }); /* This server is not longer the target */
break;
case messageType.TARGET: /* This server is now the target! */
this.target = true;
Invoke(new editLabel(this.editLabel), new object[] { targetInfo, "TRUE" });
break;
}
}
}
catch (SocketException se)
{
if (se.ErrorCode == 123456789) /* If the error code is 123456789, the other side of the connection has probably chashed. Then we have to close the actual connection and to wait for a new client connection */
{
this.clientSocket.Close(); /* We have to close the socket (due to the crashing of the other connection side) */
this.target = false; /* And obviously this server is not longer the target. */
/*
* We have also to update the info to show to the user this server is not longer connected.
*/
Invoke(new editLabel(this.editLabel), new object[] { statusInfo, "DISCONNECTED" });
Invoke(new editLabel(this.editLabel), new object[] { targetInfo, "FALSE" });
breaker = false;
}
continue;
}
catch (IOException)
{
continue;
}
catch (ObjectDisposedException)
{
continue;
}
catch (Exception except)
{
MessageBox.Show(except.Message.ToString());
}
}
}
/*
* Function executed by the clip receiver thread.
*/
private void clipReceiverFunction()
{
message msg;
clipServer = new TcpListener(IPAddress.Any, 9998); /* Socket listening for clients connections. */
clipServer.Start(); /* The clip server starts */
byte[] data;
while (enableClipServer) /* This boolean is modified by the main window when the user perform a click on the StopServerButton */
{
try
{
using (clipReceiver = clipServer.AcceptTcpClient())
{
/* Here we are receiving the message with the clipboard data type that we are going to receive */
data = SocketCommunication.receiveBufferFromSocket(clipReceiver);
msg = SocketCommunication.rawDeserialize <message>(data);
/* If the message is not a remote paste message, there is an error, and we must throw an exception. */
if (msg.messType != messageType.REMOTE_PASTE)
{
throw new Exception("Wrong message format!");
}
switch (msg.cinf.ct)
{
case clipboardType.TEXT: /* We are going to receive text */
data = SocketCommunication.receiveChunks(clipReceiver, msg.cinf.size); /* Here we set the clipboard with the text received, encoding the received bytes with unicode format. */
Invoke(new txtSet(Clipboard.SetText), Encoding.Unicode.GetString(data)); /* Here we set the clipboard with the received text */
break;
case clipboardType.IMAGE: /* We are going to receive an Image */
data = SocketCommunication.receiveChunks(clipReceiver, msg.cinf.size); /*Function that receives data, saving chuncks of 1024 Bytes*/
Image i = (Image)SocketCommunication.deserialize(data); /* Received bytes deserialization. The received object is of type Image*/
Invoke(new imgSet(Clipboard.SetImage), i); /* Here We set the clipboard with the received Image */
break;
case clipboardType.FILES: /* FILES case. To sent multiple files, we have to compress all files in a zip Archive. Therefore, now we must unzip the received archive */
String path = SocketCommunication.receiveFile(clipReceiver, msg.cinf.size); /* This function returns the path of the received archive */
String dirName = Path.Combine(path, "temp"); /* Here we create the path to the folder that will contain all files */
if (!Directory.Exists(dirName)) /*If this folder doesn't exist...*/
{
Directory.CreateDirectory(Path.Combine(dirName)); /* we have to create it! */
}
else
{
Directory.Delete(dirName, true); /* The directory already exists, and probably contains files...*/
Directory.CreateDirectory(dirName); /* so we have to delete the directory and to recreate it, in order to save memory. */
}
ZipFile.ExtractToDirectory(Path.Combine(path, "receivedArchive.zip"), dirName); /* We unzip the archive in the folder "ReceiveTemp" */
string[] sc = Directory.GetFileSystemEntries(dirName); /*This functions returns a string array with the filenames of each element in the new folder*/
StringCollection strColl = new StringCollection(); /* Clipboard.SetFileDropList requires a StringCollection object */
strColl.AddRange(sc); /* Here we add to strColl all strings contained in sc */
Invoke(new fileSet(Clipboard.SetFileDropList), strColl); /* We have to call this functions with invoke in order to set the main thread as clipboard owner */
break;
case clipboardType.AUDIO:
data = SocketCommunication.receiveChunks(clipReceiver, msg.cinf.size); /*Function that receives data, saving chuncks of 1024 Bytes*/
Stream audio = (Stream)SocketCommunication.deserialize(data); /* Received bytes deserialization. The received object is of type Stream*/
Invoke(new audioSet(Clipboard.SetAudio), audio); /* Here We set the clipboard with the received Audio stream */
break;
}
}
}
catch (SocketException)
{
continue;
}
catch (IOException)
{
continue;
}
catch (ObjectDisposedException)
{
continue;
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
}
/*
* Function that receives the clipboard data and sets the client clipboard with the received data.
*/
public void remoteCopy(TcpClient clipClient)
{
message msg;
/*
* Here we receive the struct that contains the data type that is going to arrive.
*/
byte[] data = SocketCommunication.receiveBufferFromSocket(clipClient);
msg = SocketCommunication.rawDeserialize <message>(data);
/*
* If we do not receive a messageType == remote_copy, there is an error!
*/
if (msg.messType != messageType.REMOTE_COPY)
{
throw new Exception("Formato messaggio copia errato.");
}
switch (msg.cinf.ct)
{
case clipboardType.TEXT: /*The clipboard data is text*/
data = SocketCommunication.receiveChunks(clipClient, msg.cinf.size); /*Function that receives data, saving chuncks of 1024 Bytes*/
/* We have to call this functions with an invoke in order to set the main thread as clipboard owner */
Invoke(new txtSet(Clipboard.SetText), Encoding.Unicode.GetString(data)); /* Here we set the clipboard with the text received, encoding the received bytes with unicode format. */
break;
case clipboardType.IMAGE: /* The clipboard data is an Image */
data = SocketCommunication.receiveChunks(clipClient, msg.cinf.size); /*Function that receives data, saving chuncks of 1024 Bytes*/
Image i = (Image)SocketCommunication.deserialize(data); /* Received bytes deserialization. The received object is of type Image*/
Invoke(new imgSet(Clipboard.SetImage), i); /* Here We set the clipboard with the received Image */
break;
case clipboardType.FILES: /* FILES case. To sent multiple files, we have to compress all files in a zip Archive. Therefore, now we must unzip the received archive */
String path = SocketCommunication.receiveFile(clipClient, msg.cinf.size); /* This function returns the path of the received archive */
String dirName = Path.Combine(path, "ReceiveTemp"); /* Here we create the path to the folder that will contain all files */
if (!Directory.Exists(dirName)) /*If this folder doesn't exist...*/
{
Directory.CreateDirectory(dirName); /* we have to create it! */
}
else
{
Directory.Delete(dirName, true); /* The directory already exists, and probably contains files...*/
Directory.CreateDirectory(dirName); /* so we have to delete the directory and to recreate it, in order to save memory. */
}
ZipFile.ExtractToDirectory(Path.Combine(path, "receivedArchive.zip"), dirName); /* We unzip the archive in the folder "ReceiveTemp" */
File.Delete(Path.Combine(path, "receivedArchive.zip")); /*Then we delete the received zip, in order to save memory.*/
string[] sc = Directory.GetFileSystemEntries(dirName); /*This functions returns a string array with the filenames of each element in the new folder*/
StringCollection strColl = new StringCollection(); /* Clipboard.SetFileDropList requires a StringCollection object */
strColl.AddRange(sc); /* Here we add to strColl all strings contained in sc */
Invoke(new fileSet(Clipboard.SetFileDropList), strColl); /* We have to call this functions with an invoke in order to set the main thread as clipboard owner */
break;
case clipboardType.AUDIO: /* The clipboard data is an audio stream. */
data = SocketCommunication.receiveChunks(clipClient, msg.cinf.size); /*Function that receives data, saving chuncks of 1024 Bytes*/
Stream audio = (Stream)SocketCommunication.deserialize(data); /* Received bytes deserialization. The received object is of type Stream*/
Invoke(new audioSet(Clipboard.SetAudio), audio); /* Here We set the clipboard with the received Audio stream */
break;
case clipboardType.NO_VALID_DATA: /*If the clipboard doesn't contain a valid data format, we receive this message.*/
data = SocketCommunication.receiveChunks(clipClient, msg.cinf.size);
break;
}
}
