/*
         * Event handler for clicks on the "Disconnect" in the contextMenuStrip
         */
        private void disconnectServerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            TcpClient toRemove = this.remoteHosts[ServerList.SelectedItem.ToString()]; /* The client to remove is the client current selected */


            if (this.targetServer != null && this.targetServer.Equals(toRemove)) /*If we are removing the actual target server we have to assign null to tcpcl in order to avoid*/
            {
                this.targetServer = null;                                        /*transfers toward a disconnected server.*/
            }
            try
            {
                if (toRemove != null && toRemove.Connected) /* Standards checks */
                {
                    message msg = new message();
                    msg.messType = messageType.DISCONNECT; /* Message Type: Disconnect! */

                    byte[] buffer = SocketCommunication.rawSerialize(msg);
                    SocketCommunication.sendBufferToSocket(buffer, toRemove);
                }

                toRemove.Close();                                                 /*Here we are closing the socket connected with the server to remove from ServerList*/
                this.remoteHosts.Remove(ServerList.SelectedItem.ToString());      /* We have to remove the server from tme remoteHosts dictionary */
                this.ServerList.Items.Remove(ServerList.SelectedItem.ToString()); /* And from the extern list! */
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        /*
         * Button to close the application
         */
        private void X_Click(object sender, EventArgs e)
        {
            /*
             * First thing: sending a DISCONNECT message to all connected servers.
             */
            if (remoteHosts != null)
            {
                foreach (TcpClient tc in this.remoteHosts.Values)
                {
                    if (tc.Connected) /*If tc is still an active server*/
                    {
                        message msg = new message();
                        msg.messType = messageType.DISCONNECT;

                        byte[] buffer = SocketCommunication.rawSerialize(msg);
                        SocketCommunication.sendBufferToSocket(buffer, tc);

                        tc.Close(); /* Socket close! */
                    }
                }
            }

            /*
             * Here we close the application.
             */
            Application.Exit();
        }
        /*
         * Listener for mouse wheel in the "MouseArea box". Here we capture each mouse wheel in MouseArea box and we will send this event (mouse wheel)
         * toward the server actually connected.
         */
        private void MouseArea_MouseWheel(object sender, MouseEventArgs e)
        {
            message msg = new message();

            try
            {
                if (targetServer != null && targetServer.Connected) /* If no server is actually connected, we have to sent nothing */
                {
                    msg.act.eventype      = EVENTYPE.MOUSE_WHEEL;   /* Event type: Mouse Wheel! */
                    msg.act.wheelMovement = e.Delta;                /* e.Delta contains the number of wheel rotations. */

                    msg.messType = messageType.ACTION;              /* Type of message: mouse or keyboard action, that must be sent via SendInput by the Server. */

                    /*
                     * Here we send all data to the server via Socket.
                     */
                    byte[] buffer = SocketCommunication.rawSerialize(msg);        /*Raw Serialize: Struct Serialization*/
                    SocketCommunication.sendBufferToSocket(buffer, targetServer); /*Buffer sending*/
                }
            }
            catch (Exception ex) /*If some exception occurs, we will show a message with the Error Description*/
            {
                MessageBox.Show(ex.Message);
            }
        }
        /*
         * Listener for mouse movements in the "MouseArea box". Here we capture each mouse movement and we send this event (mouse coordinates update)
         * toward the server actually connected.
         */
        private void MouseArea_MouseMove(object sender, MouseEventArgs e)
        {
            message msg = new message(); /* Message struct to send to the Server */

            try
            {
                if (targetServer != null && targetServer.Connected) /* If no server is actually connected, we have to sent nothing */
                {
                    msg.act.eventype = EVENTYPE.MOUSE_MOVEMENT;     /* Type of event: mouse movement */

                    /*
                     * Mouse coordinates in the MouseArea box, that maps the server screen. The mouse coordinates ti send with SendInput are mapped
                     * in the value range 0 - 65536.
                     */
                    msg.act.x = (Cursor.Position.X - MouseArea.Location.X) * 65536 / MouseArea.Width;
                    msg.act.y = (Cursor.Position.Y - MouseArea.Location.Y) * 65536 / MouseArea.Height;

                    msg.messType = messageType.ACTION; /* Type of message: mouse or keyboard action, that must be sent via SendInput by the Server. */

                    /*
                     * Here we send all data to the server via Socket.
                     */
                    byte[] buffer = SocketCommunication.rawSerialize(msg);        /*Raw Serialize: Struct Serialization*/
                    SocketCommunication.sendBufferToSocket(buffer, targetServer); /*Buffer sending*/
                }
            }
            catch (Exception ex) /*If some exception occurs, we will show a message with the Error Description*/
            {
                MessageBox.Show(ex.Message);
            }
        }
        /*
         * Performing a double click in a server in the Server List, we will select this server as Target, and we will update
         * the server clipboard with the clipboard data actually present in the client.
         */
        private void ServerList_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            message msg = new message();

            if (ServerList.SelectedItem == null)
            {
                return;                                                     /* If we perform a double click where there is no item, return here. */
            }
            TcpClient cl = remoteHosts[ServerList.SelectedItem.ToString()]; /*The new Server is the current selected server.*/

            byte[] buffer;

            try
            {
                if (this.targetServer == null || !this.targetServer.Equals(cl))   /* If we are selecting the same target server, we do not have to send TARGET_CHANGED and TARGET messages */
                {
                    if (this.targetServer != null && this.targetServer.Connected) /*Here we are informing the old server that it is not longer the client target*/
                    {
                        msg.messType = messageType.TARGET_CHANGED;                /* Type of message: Target_Changed! */

                        buffer = SocketCommunication.rawSerialize(msg);
                        SocketCommunication.sendBufferToSocket(buffer, targetServer);
                    }

                    /*
                     * Here we change the Server and we will inform the new server that it is the new client target!
                     */

                    this.targetServer = cl;            /*The new tcpcl is the selected Server cl*/

                    msg.messType = messageType.TARGET; /* Type of message: Target! */

                    buffer = SocketCommunication.rawSerialize(msg);
                    SocketCommunication.sendBufferToSocket(buffer, targetServer);
                }

                /*
                 * Performing this operation we will unblock the sender thread, that Will analyze the clipboard and will send clipboard
                 * data toward the new Server. Note that if we perform a double click on the current target server, this operation will be anyway performed.
                 */
                send.Set();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        /*
         * The system calls this function every time a new keyboard input event is about to be posted into this thread input queue.
         * In fact, this function is the keyboard listener, that send keyboards Events toward the current targete server.
         */
        public int LowLevelKeyboardProc(int code, int wParam, ref keyboardHookStruct lParam)
        {
            message msg = new message();

            byte[] buffer;

            try
            {
                /* A code the hook procedure uses to determine how to process the message. If nCode is less than zero,
                 * the hook procedure must pass the message to the CallNextHookEx function without further processing and
                 * should return the value returned by CallNextHookEx. Obviously, to send the message tcpcl has to be connected and not null :)
                 */
                if (code >= 0 && targetServer != null && targetServer.Connected)
                {
                    if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))     /* keydown case. We send toward the server both normal keys and system keys. */
                    {
                        msg.act.eventype = EVENTYPE.KEY_DOWN;
                    }
                    else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP))    /* Keyup case. */
                    {
                        msg.act.eventype = EVENTYPE.KEY_UP;
                    }

                    msg.act.keypress = lParam.vkCode;     /* vkCode of the kay that has been pressed. */
                    msg.messType     = messageType.ACTION;

                    buffer = SocketCommunication.rawSerialize(msg);
                    SocketCommunication.sendBufferToSocket(buffer, targetServer);

                    return(1);
                }
                else
                {
                    /*
                     * We do not perform any operation and we call the next function in the HookProcChain.
                     */
                    return(CallNextHookEx(hhook, code, wParam, ref lParam));
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return(CallNextHookEx(hhook, code, wParam, ref lParam)); /*If an exception*/
            }
        }
Esempio n. 7
0
        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);
            }
        }
        /*
         * Listener for "mouse ups" in the "MouseArea box". Here we capture each mouse up event in MouseArea box
         * and we will send this event (mouse left/right up) toward the server actually connected.
         */
        private void MouseArea_MouseUp(object sender, MouseEventArgs e)
        {
            message msg = new message();

            try
            {
                if (targetServer != null && targetServer.Connected) /* If no server is actually connected, we have to sent nothing */
                {
                    /*
                     * Here we have to Identify which mouse button has been released. MouseEventArgs contains this kind of information.
                     */
                    if (e.Button == MouseButtons.Left)
                    {
                        msg.act.eventype = EVENTYPE.LEFT_UP;
                    }
                    else if (e.Button == MouseButtons.Right)
                    {
                        msg.act.eventype = EVENTYPE.RIGHT_UP;
                    }
                    else if (e.Button == MouseButtons.Middle)
                    {
                        msg.act.eventype = EVENTYPE.MIDDLE_UP;
                    }

                    msg.messType = messageType.ACTION; /* Type of message: mouse or keyboard action, that must be sent via SendInput by the Server. */

                    /*
                     * Here we send all data to the server via Socket.
                     */
                    byte[] buffer = SocketCommunication.rawSerialize(msg);        /*Raw Serialize: Struct Serialization*/
                    SocketCommunication.sendBufferToSocket(buffer, targetServer); /*Buffer sending*/
                }
            }
            catch (Exception ex) /*If some exception occurs, we will show a message with the Error Description*/
            {
                MessageBox.Show(ex.Message.ToString());
            }
        }
        /*
         * Function of clipSender thread. This thread will stay blocked waiting for a condition variable set, performed by the main thread
         * when the user perform a copy/cut operation.
         */
        private void clipSenderFunction()
        {
            message msg = new message();

            byte[] data = null;

            while (enableClipSender)        /*This function runs until the Application is active or the user makes a click on StopServerButton.*/
            {
                try
                {
                    send.WaitOne();         /* Wait for a notification from the main thread */

                    if (!enableClipSender)  /* If the main thread has set this boolean to false, this thread will terminate here. */
                    {
                        break;
                    }

                    IPEndPoint remoteIpEndPoint = clientSocket.Client.RemoteEndPoint as IPEndPoint; /* IP address of the client actually connected */

                    msg.messType = messageType.REMOTE_COPY;                                         /* The operation to perform is a RemoteCopy! */

                    if (Clipboard.ContainsText())                                                   /* The clipboard contains text! */
                    {
                        String text = Clipboard.GetText();                                          /* Here we get the text copied in the clipboard */

                        data = Encoding.Unicode.GetBytes(text);                                     /* We have to get the byte array of the text, in order to send this through a socket. */

                        msg.cinf.ct = clipboardType.TEXT;                                           /* We are sending text! */
                    }
                    else if (Clipboard.ContainsImage())                                             /*The clipboard contains an Image!*/
                    {
                        Image img = Clipboard.GetImage();                                           /*We have to get the image object..*/

                        data = SocketCommunication.serialize(img);                                  /* and to serialize it! */

                        msg.cinf.ct = clipboardType.IMAGE;                                          /*The data is an Image*/
                    }
                    else if (Clipboard.ContainsAudio())                                             /* The clipboard contains an audio stream! */
                    {
                        Stream audio = Clipboard.GetAudioStream();                                  /*We have to get the stream object..*/

                        data = SocketCommunication.serialize(audio);                                /* and to serialize it! */

                        msg.cinf.ct = clipboardType.AUDIO;                                          /* The clipboard data is an audio stream! */
                    }
                    else if (Clipboard.ContainsFileDropList())                                      /* The clipboard contains files! */
                    {
                        string archPath = SocketCommunication.createArchive();                      /*This function creates an archive with all files in the clipboard*/

                        FileInfo fi = new FileInfo(archPath);                                       /* Object containing info about the archive */

                        if (fi.Length > 10 * 1024 * 1024)                                           /* If the zip size is more than 10 MB */
                        {
                            DialogResult confirmResult = MessageBox.Show("Sei davvero sicuro di voler trasferire più di 10 MB di dati?",
                                                                         "Conferma Trasferimento",
                                                                         MessageBoxButtons.YesNo); /* We have to show a confirm button, in order to avoid network overhead. */

                            if (confirmResult == DialogResult.No)                                  /* If the user doesn't want to transfer the file.. */
                            {
                                continue;                                                          /* We have to continue */
                            }
                        }

                        msg.cinf.ct = clipboardType.FILES;                      /* The clipboard data is a FileDropList! */

                        msg.cinf.size = (int)fi.Length;                         /* Size of the archive that is going to be sent */

                        using (clipClient = new TcpClient())                    /* Socket used to send clipboard data to server */
                        {
                            clipClient.Connect(remoteIpEndPoint.Address, 9999); /* We have to connect to the target server, port 9999 */

                            SocketCommunication.sendBufferToSocket(SocketCommunication.rawSerialize(msg), clipClient);

                            SocketCommunication.sendFileToSocket(clipClient, archPath);
                        }

                        File.Delete(archPath);

                        continue;
                    }
                    else
                    {
                        msg.cinf.ct = clipboardType.NO_VALID_DATA;

                        data = new byte[4];
                    }

                    if (data.Length > 10 * 1024 * 1024)             /* If the data size is more than 10 MB */
                    {
                        DialogResult confirmResult = MessageBox.Show("Sei davvero sicuro di voler trasferire più di 10 MB di dati?",
                                                                     "Conferma Trasferimento",
                                                                     MessageBoxButtons.YesNo); /* We have to show a confirm button, in order to avoid network overhead. */

                        if (confirmResult == DialogResult.No)                                  /* If the user doesn't want to transfer the file.. */
                        {
                            continue;                                                          /* We have to continue */
                        }
                    }

                    msg.cinf.size = data.Length;

                    using (clipClient = new TcpClient())
                    {
                        clipClient.Connect(remoteIpEndPoint.Address, 9999);

                        SocketCommunication.sendBufferToSocket(SocketCommunication.rawSerialize(msg), clipClient);      /*Struct Sending*/
                        SocketCommunication.sendChunks(clipClient, data);                                               /* Data sending */
                    }
                }
                catch (SocketException)     /* The exceptions that occurs will be catched here and the thread will not terminate! This thread has to remain active while the application ends */
                {
                    continue;
                }
                catch (IOException)
                {
                    continue;
                }
                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 of clipSender thread. This thread will stay blocked waiting for a condition variable set, performed by the main thread
         * when the user makes a double click on a server.
         */
        private void clipSenderFunction()
        {
            byte[] data;

            while (true) /*This function runs until the Application is active.*/
            {
                try
                {
                    Invoke(new makeInvisible(makeInvisible), remotePasteProgressBar);                     /* If a remote paste progress bar is visible, we have to make it invisible */

                    send.WaitOne();                                                                       /*Wait for a notification from the main thread*/

                    Invoke(new makeVisible(makeVisible), remotePasteProgressBar);                         /* Because we have to send data toward the targetServer, we show the progressBar to inform the user on the transfer */

                    IPEndPoint remoteServerIpEndPoint = targetServer.Client.RemoteEndPoint as IPEndPoint; /*Get ip address of the server actually connected*/

                    message msg = new message();

                    msg.messType = messageType.REMOTE_PASTE;       /* The operation to perform is a remote paste! */

                    if (Clipboard.ContainsText())                  /* The clipboard contains text! */
                    {
                        String text = Clipboard.GetText();         /* Here we get the text copied in the clipboard */

                        data = Encoding.Unicode.GetBytes(text);    /* We have to get the byte array of the text, in order to send this through a socket. */

                        msg.cinf.ct   = clipboardType.TEXT;        /* We are sending text! */
                        msg.cinf.size = data.Length;               /* We have to sent even the amount of text bytes in order to receive the whole array */
                    }
                    else if (Clipboard.ContainsImage())            /*The clipboard contains an Image!*/
                    {
                        Image img = Clipboard.GetImage();          /*We have to get the image object..*/

                        data = SocketCommunication.serialize(img); /* and to serialize it! */

                        msg.cinf.ct   = clipboardType.IMAGE;       /*The data is an Image*/
                        msg.cinf.size = data.Length;
                    }
                    else if (Clipboard.ContainsAudio())              /* The clipboard contains an audio stream! */
                    {
                        Stream audio = Clipboard.GetAudioStream();   /*We have to get the stream object..*/

                        data = SocketCommunication.serialize(audio); /* and to serialize it! */

                        msg.cinf.ct   = clipboardType.AUDIO;         /* Tha clipboard data is an audio stream! */
                        msg.cinf.size = data.Length;
                    }
                    else if (Clipboard.ContainsFileDropList())                 /* The clipboard contains files! */
                    {
                        string archPath = SocketCommunication.createArchive(); /*This function creates an archive with all files in the clipboard*/

                        FileInfo fi = new FileInfo(archPath);                  /* Object containing info about the archive */

                        if (fi.Length > 10 * 1024 * 1024)                      /* If the zip size is more than 10 MB */
                        {
                            DialogResult confirmResult = MessageBox.Show("Sei davvero sicuro di voler trasferire più di 10 MB di dati?",
                                                                         "Conferma Trasferimento",
                                                                         MessageBoxButtons.YesNo); /* We have to show a confirm button, in order to avoid network overhead. */

                            if (confirmResult == DialogResult.No)                                  /* If the user doesn't want to transfer the file.. */
                            {
                                continue;                                                          /* We have to continue */
                            }
                        }

                        msg.cinf.ct   = clipboardType.FILES;                              /* The clipboard data is a FileDropList! */
                        msg.cinf.size = (int)fi.Length;                                   /* Size of the archive that is going to be sent */

                        using (TcpClient clientSendData = new TcpClient())                /*Socket used to send clipboard data to server */
                        {
                            clientSendData.Connect(remoteServerIpEndPoint.Address, 9998); /* We have to connect to the target server, port 9998 */

                            SocketCommunication.sendBufferToSocket(SocketCommunication.rawSerialize(msg), clientSendData);
                            SocketCommunication.sendFileToSocket(clientSendData, archPath);

                            clientSendData.Close();
                        }

                        continue;
                    }
                    else
                    {
                        msg.cinf.ct = clipboardType.NO_VALID_DATA;
                        data        = new byte[4];
                    }

                    if (data.Length > 10 * 1024 * 1024) /* If the clipboard data is bigger than 10 MB */
                    {
                        DialogResult confirmResult = MessageBox.Show("Sei davvero sicuro di voler trasferire più di 10 MB di dati?",
                                                                     "Conferma Trasferimento",
                                                                     MessageBoxButtons.YesNo); /* We have to show a confirm button, in order to avoid network overhead. */

                        if (confirmResult == DialogResult.No)                                  /* If the user doesn't want to transfer the file.. */
                        {
                            continue;                                                          /* We have to continue */
                        }
                    }

                    using (TcpClient clientSendData = new TcpClient())                                                 /*Socket used to send clipboard data to server */
                    {
                        clientSendData.Connect(remoteServerIpEndPoint.Address, 9998);                                  /* We have to connect to the target server, port 9998 */

                        SocketCommunication.sendBufferToSocket(SocketCommunication.rawSerialize(msg), clientSendData); /* Struct Sending */
                        SocketCommunication.sendChunks(clientSendData, data);                                          /* Data sending */

                        clientSendData.Close();
                    }
                }
                catch (SocketException) /* The exceptions that occurs will be catched here and the thread will not terminate! This thread has to remain active while the application ends */
                {
                    continue;
                }
                catch (IOException)
                {
                    continue;
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message);
                }
            }
        }