Esempio n. 1
0
        // Asynchronous read call-back for the standard output and error streams of the executed process.
        //
        // This call-back method fills the state object's buffer with the received data, and writes it to the socket.
        private void LocalReadCallback(IAsyncResult iAsyncResult)
        {
            LocalStateObject localStateObject = (LocalStateObject)iAsyncResult.AsyncState;
            Socket socket = localStateObject.Socket;
            Stream stream = localStateObject.Stream;
            NVT nvt = new NVT();
            try
            {
                int read = stream.EndRead(iAsyncResult);
                if (0 < read)
                {
                    string str = Encoding.ASCII.GetString(localStateObject.Buffer, 0, read); // Debug.
                    nvt.Write(localStateObject.Buffer, 0, read);
                    int r = nvt.Read(localStateObject.Buffer, 0, read);
                    // Lock the socket, just in case the other call-back wants to write at the same time.
                    lock (socket)
                    {
                        socket.Send(localStateObject.Buffer, r, 0);
                    }

                    // Reassociate the stream's BeginRead() method with the LocalReadCallback().
                    stream.BeginRead(localStateObject.Buffer, 0, LocalStateObject.BUFFER_SIZE, new AsyncCallback(LocalReadCallback), localStateObject);
                }
                else
                {
                    stream.Close();
                }
            }
            catch (ObjectDisposedException)
            {
                // If we reach this point, it means that either the socket or the processed stream were closed, so we have nothing
                // else to do here. Close the socket, the process, and the stream, just in case.
                localStateObject.Socket.Close();
                localStateObject.Process.Close();
                localStateObject.Stream.Close();
            }
        }
Esempio n. 2
0
 // Asynchronous read call-back for the socket object.
 //
 // This call-back method fills the state object's buffer with the received data, and writes it to the process' standard input.
 private void ReadCallback(IAsyncResult iAsyncResult)
 {
     StateObject stateObject = (StateObject)iAsyncResult.AsyncState;
     Socket socket = stateObject.Socket;
     NVT nvt = new NVT();
     try
     {
         int read = socket.EndReceive(iAsyncResult);
         if (0 < read)
         {
             // Handle the received data and reassociate the call-back with the socket's BeginReceive().
             StreamWriter streamWriter = stateObject.Process.StandardInput;
             string str = Encoding.ASCII.GetString(stateObject.Buffer, 0, read); // Debug.
             nvt.Write(stateObject.Buffer, 0, read);
             int r = nvt.Read(stateObject.Buffer, 0, read);
             streamWriter.Write(Encoding.ASCII.GetString(stateObject.Buffer, 0, r));
             socket.BeginReceive(stateObject.Buffer, 0, StateObject.BUFFER_SIZE, 0, new AsyncCallback(ReadCallback), stateObject);
         }
         else
         {
             socket.Close();
         }
     }
     catch(ObjectDisposedException)
     {
         // If we reach this point, it means that either the socket or the process' standard input were closed, so we have nothing
         // else to do here. Close the socket and the process, just in case.
         stateObject.Socket.Close();
         stateObject.Process.Close();
     }
 }