2008-03-05 09:52:00 -05:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Microsoft Research Singularity
|
|
|
|
//
|
|
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
//
|
|
|
|
// Note: Simple Singularity telnet daemon.
|
|
|
|
//
|
|
|
|
|
|
|
|
namespace Microsoft.Singularity.Telnetd
|
|
|
|
{
|
|
|
|
using System;
|
|
|
|
using System.Net;
|
|
|
|
using System.Net.Sockets;
|
|
|
|
using System.Text;
|
|
|
|
using System.Threading;
|
|
|
|
|
|
|
|
using Microsoft.Singularity.Channels;
|
|
|
|
using Microsoft.Singularity.Io;
|
|
|
|
|
|
|
|
internal sealed class Connection
|
|
|
|
{
|
|
|
|
const byte IAC = 255; // telnet "interpret as command" escape
|
|
|
|
const byte CODE_WILL = 251; // telnet commands
|
|
|
|
const byte CODE_WONT = 252;
|
|
|
|
const byte CODE_DO = 253;
|
|
|
|
const byte CODE_DONT = 254;
|
|
|
|
const byte OPTION_ECHO = 0x01; // telnet command options
|
|
|
|
const byte OPTION_SUPPRESSGA = 0x03;
|
|
|
|
|
|
|
|
private Socket socket;
|
|
|
|
private Process process;
|
|
|
|
private TRef<UnicodePipeContract.Imp:READY> m_stdinImp;
|
|
|
|
|
|
|
|
public Connection(Socket socket)
|
|
|
|
{
|
|
|
|
this.socket = socket;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void Start()
|
|
|
|
{
|
|
|
|
ThreadStart threadStart = new ThreadStart(Run);
|
|
|
|
Thread thread = new Thread(threadStart);
|
|
|
|
thread.Start();
|
|
|
|
}
|
|
|
|
|
|
|
|
private void Run()
|
|
|
|
{
|
|
|
|
// Send options and welcome message to the client
|
|
|
|
SendCommand(IAC, CODE_DONT, OPTION_ECHO);
|
|
|
|
SendCommand(IAC, CODE_WILL, OPTION_SUPPRESSGA);
|
|
|
|
Send("Microsoft Singularity Telnet Daemon\r\n\r\n");
|
|
|
|
|
|
|
|
// Start a shell process with redirected IO
|
|
|
|
string[] commands = new string[] { "shell" };
|
|
|
|
process = new Process(commands, null, 2);
|
|
|
|
if (process == null) {
|
|
|
|
Console.WriteLine("Singularity Telnet Daemon - failed to exec shell.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
UnicodePipeContract.Imp! stdinImp;
|
|
|
|
UnicodePipeContract.Exp! stdinExp;
|
|
|
|
UnicodePipeContract.NewChannel(out stdinImp, out stdinExp);
|
|
|
|
|
|
|
|
UnicodePipeContract.Imp! stdoutImp;
|
|
|
|
UnicodePipeContract.Exp! stdoutExp;
|
|
|
|
UnicodePipeContract.NewChannel(out stdoutImp, out stdoutExp);
|
|
|
|
|
|
|
|
process.SetStartupEndpoint(0, (Endpoint * in ExHeap) stdinExp);
|
|
|
|
process.SetStartupEndpoint(1, (Endpoint * in ExHeap) stdoutImp);
|
|
|
|
process.Start();
|
|
|
|
|
|
|
|
// Kick off another thread that will pump the data from the socket to shell stdin
|
|
|
|
m_stdinImp = new TRef<UnicodePipeContract.Imp:READY>(stdinImp);
|
|
|
|
ThreadStart threadStart = new ThreadStart(WaitOnSocket);
|
|
|
|
Thread thread = new Thread(threadStart);
|
|
|
|
thread.Start();
|
|
|
|
|
|
|
|
// Process all output from the shell
|
|
|
|
bool abort = false;
|
2008-11-17 18:29:00 -05:00
|
|
|
while (!abort) {
|
2008-03-05 09:52:00 -05:00
|
|
|
switch receive {
|
|
|
|
case stdoutExp.Write(buffer, offset, count):
|
|
|
|
Send(buffer, offset, count);
|
|
|
|
stdoutExp.SendAckWrite(buffer);
|
|
|
|
break;
|
|
|
|
case stdoutExp.ChannelClosed():
|
|
|
|
Console.WriteLine("Singularity Telnet Daemon - ending connection.");
|
|
|
|
abort = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
delete stdoutExp;
|
|
|
|
socket.Close();
|
|
|
|
}
|
|
|
|
|
|
|
|
private void WaitOnSocket()
|
|
|
|
{
|
|
|
|
UnicodePipeContract.Imp:READY! stdinImp = m_stdinImp.Acquire();
|
|
|
|
byte[] localBuffer = new byte[256];
|
|
|
|
bool abort = false;
|
2008-11-17 18:29:00 -05:00
|
|
|
while (!abort) {
|
2008-03-05 09:52:00 -05:00
|
|
|
try {
|
|
|
|
int count = socket.Receive(localBuffer);
|
|
|
|
#if DebugTracingOn
|
|
|
|
DebugStub.Write("Receive " + count + "b:");
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
|
|
DebugStub.Write(" " + localBuffer[i]);
|
|
|
|
}
|
|
|
|
DebugStub.WriteLine();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (count > 0) {
|
|
|
|
// REVIEW: If we only care about ASCII we have the same sized buffers...
|
|
|
|
char[] in ExHeap buffer = new [ExHeap] char[localBuffer.Length];
|
|
|
|
int dataCount = 0;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
|
|
if (localBuffer[i] == IAC) {
|
|
|
|
i += 2; // TODO: Handle split 3 byte sequences and other forms
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
buffer[dataCount] = (char)localBuffer[i];
|
|
|
|
dataCount++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Send the data and wait for acknowledgement
|
|
|
|
stdinImp.SendWrite(buffer, 0, dataCount);
|
|
|
|
switch receive {
|
|
|
|
case stdinImp.AckWrite(returnedBuffer):
|
|
|
|
delete returnedBuffer;
|
|
|
|
break;
|
|
|
|
case stdinImp.ChannelClosed():
|
|
|
|
abort = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (SocketException) {
|
|
|
|
Console.WriteLine("Socket Exception on input thread");
|
|
|
|
abort = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
delete stdinImp;
|
|
|
|
socket.Close();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Send - encode and sends
|
|
|
|
private void Send(char[]! in ExHeap buffer, int offset, int count)
|
|
|
|
{
|
|
|
|
// REVIEW: it's silly to copy the buffer locally because it's going to a socket
|
|
|
|
char[] localBuffer = new char[count];
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
|
|
localBuffer[i] = buffer[offset + i];
|
|
|
|
}
|
|
|
|
byte[] encodedBuffer = Encoding.ASCII.GetBytes(localBuffer);
|
|
|
|
SendRawBytes(encodedBuffer, 0, encodedBuffer.Length);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Send - encode and sends
|
|
|
|
private void Send(string! s)
|
|
|
|
{
|
|
|
|
byte[] buffer = Encoding.ASCII.GetBytes(s);
|
|
|
|
SendRawBytes(buffer, 0, buffer.Length);
|
|
|
|
}
|
|
|
|
|
|
|
|
// SendCommand - assembles and sends the standard three byte command
|
|
|
|
private void SendCommand(byte iac, byte code, byte option)
|
|
|
|
{
|
|
|
|
byte[] buffer = new byte[] { iac, code, option };
|
|
|
|
SendRawBytes(buffer, 0, buffer.Length);
|
|
|
|
}
|
|
|
|
|
|
|
|
// SendRawBytes - base function for sending already encoded data to client
|
|
|
|
private void SendRawBytes(byte[] buffer, int offset, int count)
|
|
|
|
{
|
|
|
|
#if DebugTracingOn
|
|
|
|
DebugStub.Write("Send " + count + "b:");
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
|
|
DebugStub.Write(" " + buffer[offset + i]);
|
|
|
|
}
|
|
|
|
DebugStub.WriteLine();
|
|
|
|
#endif
|
|
|
|
if (count <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
socket.Send(buffer, offset, count, SocketFlags.None);
|
|
|
|
}
|
|
|
|
catch (SocketException) {
|
|
|
|
Console.WriteLine("Socket Exception writing string.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|