/// <summary>
/// Ends the current client connection.
/// </summary>
/// <param name="sender">The current server to client connection channel.</param>
private void EndConnection(Imap4SslProxyConnection sender)
{
// Release the current client connection
// resources and make avaliable a new connection.
if (_client[sender.ClientIndex] != null)
{
_client[sender.ClientIndex].Dispose();
_client[sender.ClientIndex] = null;
// Decrement the count.
Interlocked.Decrement(ref _clientCount);
// Signal to the blocking handler
// to un-block.
_connAvailable.Set();
}
}
/// <summary>
/// Unknown command received.
/// </summary>
/// <param name="sender">The current server to client connection channel.</param>
private void Unknown(Imap4SslProxyConnection sender)
{
if (sender.Connected)
{
// Reply to client with unknown command.
ReplyToSender(sender, "-ERR Unknown command");
}
else
{
// If an unknown command is sent when the channel is opened
// but the user has not supplied valid credentials then close
// the socket channel to the client. This is needed when a
// client opens a socket channel and starts sending a DOS
// attack.
Disconnect(sender, sender.Prefix + " LOGOUT");
}
}
/// <summary>
/// Connect the client to the server.
/// </summary>
/// <param name="sender">The current server to client connection channel.</param>
/// <param name="data">The data from the client.</param>
private void Connect(Imap4SslProxyConnection sender, string data)
{
try
{
// Add custom validation here.
// Get the current data.
string dataArray = data.Trim();
string userPassword = string.Empty;
string prefix = string.Empty;
// Start and end of the login index.
int start = dataArray.ToUpper().IndexOf("LOGIN") + 5;
userPassword = dataArray.Substring(start);
// Get the prefix of the current
// message request.
int endPrefix = dataArray.IndexOf(" ");
prefix = dataArray.Substring(0, endPrefix).Trim();
// Get the user name and passord
// of the client creadentials.
sender.ConnectionName = userPassword;
sender.Prefix = prefix;
sender.Connected = true;
// Send the command to the imap4 server.
sender.SendSocketCommand(data);
}
catch (Exception e)
{
// Detect a thread abort exception.
if (e is ThreadAbortException)
{
Thread.ResetAbort();
}
base.Write("Imap4SslProxyServer", "Connect", e.Message,
382, WriteTo.EventLog, LogType.Error);
// Reply to client internal server error command.
ReplyToSender(sender, "500 Error");
}
}
/// <summary>
/// Disconnect the client from the server, close the channel.
/// </summary>
/// <param name="sender">The current server to client connection channel.</param>
/// <param name="data">The data from the client.</param>
private void Disconnect(Imap4SslProxyConnection sender, string data)
{
// Add custom validation here.
// Get the current data.
string dataArray = data.Trim();
string prefix = string.Empty;
// Get the prefix of the current
// message request.
int endPrefix = dataArray.IndexOf(" ");
prefix = dataArray.Substring(0, endPrefix).Trim();
sender.Prefix = prefix;
// Disconnect the client.
sender.Connected = false;
sender.Disconnect(data);
sender = null;
}
/// <summary>
/// Reply to the current client.
/// </summary>
/// <param name="sender">The current server to client connection channel.</param>
/// <param name="command">The command to send to the client.</param>
private void ReplyToSender(Imap4SslProxyConnection sender, string command)
{
sender.SendCommand(command);
}
/// <summary>
/// Processes all in-comming client command requests.
/// </summary>
/// <param name="sender">The current server to client connection channel.</param>
/// <param name="dataReceived">The data received from the client.</param>
private void client_OnDataReceived(Imap4SslProxyConnection sender, string dataReceived)
{
try
{
// Decrypt the data recived from the client.
string receivedData = dataReceived.Trim();
string command = string.Empty;
// Get specific commands from the client.
if (receivedData.ToUpper().IndexOf("LOGOUT") > -1)
{
command = "LOGOUT";
}
else if (receivedData.ToUpper().IndexOf("LOGIN") > -1)
{
command = "LOGIN";
}
else if (receivedData.ToUpper().IndexOf("ENDC") > -1)
{
command = "ENDC";
}
else
{
command = receivedData;
}
// Delay.
System.Threading.Thread.Sleep(10);
// Process the command.
switch (command.ToUpper())
{
case "LOGOUT":
// Close the client connection.
Disconnect(sender, receivedData);
break;
case "LOGIN":
// User name.
Connect(sender, receivedData);
break;
case "ENDC":
// End the client connection.
EndConnection(sender);
break;
default:
// An unknown command sent.
//Unknown(sender);
sender.SendSocketCommand(receivedData);
break;
}
}
catch (Exception e)
{
// Detect a thread abort exception.
if (e is ThreadAbortException)
{
Thread.ResetAbort();
}
base.Write("Imap4SslProxyServer", "client_OnDataReceived", e.Message,
292, WriteTo.EventLog, LogType.Error);
// Reply to client internal server error command.
ReplyToSender(sender, "500 Error");
}
}
/// <summary>
/// Starts listening on the specified port.
/// </summary>
public void StartListen()
{
try
{
// Get the imap4 server information from
// the configuration file, the host and
// port of the imap4 server is located in
// the default section, this data is used
// to connect to the imap4 server.
GetImap4ServerHost();
// Get the listening port from the configuration
// file, if no port specified then default or
// the current port set will be used.
GetListeningPort();
// Get the maximum number of clients from the configuration
// file, if no value is specified then default or
// the current value will be used.
GetMaxNumClients();
// Get the client idle time out from the configuration
// file, if no value is specified then default or
// the current value will be used.
GetClientTimeOut();
// Get the local end point, the server will listen
// on only the first IP address assigned.
//IPEndPoint endPoint = new IPEndPoint(Dns.GetHostEntry(remoteHost).AddressList[0], listenPort);
// Create a new tcp listener server,
// and start the server.
_listener = new TcpListener(System.Net.IPAddress.Any, _listenPort);
_listener.Start();
// While the server is alive accept in-comming client
// connections.
do
{
// Do not allow any more clients
// if maximum is reached.
if (_clientCount < (_maxNumClients - 1))
{
// Find the next available
// connection within the list.
for (int i = 0; i < _client.Count(); i++)
{
if (_client[i] == null)
{
_clientIndex = i;
break;
}
}
// Create a new client connection handler for the current
// tcp client attempting to connect to the server. Creates
// a new channel from the client to the server.
_client[_clientIndex] =
new Imap4SslProxyConnection(_listener.AcceptTcpClient(), _connection);
// Assign the current index.
_client[_clientIndex].ClientIndex = _clientIndex;
// if a time out has been set.
if (_timeOut > 0)
{
_client[_clientIndex].TimeOut = _timeOut;
}
// Create a new client data receive handler, this event
// handles commands from the current client.
_client[_clientIndex].OnDataReceived +=
new SslProxyImap4ReceiveHandler(client_OnDataReceived);
// Increment the count.
Interlocked.Increment(ref _clientCount);
}
else
{
base.Write("Imap4SslProxyServer", "StartListen", "Maximum number of client connections has been reached.",
120, WriteTo.EventLog, LogType.Error);
// Blocks the current thread until a
// connection becomes available.
_connAvailable.WaitOne();
}
} while (true);
}
catch (SocketException see)
{
base.Write("Imap4SslProxyServer", "StartListen", see.Message,
121, WriteTo.EventLog, LogType.Error);
}
catch (Exception e)
{
// Detect a thread abort exception.
if (e is ThreadAbortException)
{
Thread.ResetAbort();
}
base.Write("Imap4SslProxyServer", "StartListen", e.Message,
121, WriteTo.EventLog, LogType.Error);
}
finally
{
if (_listener != null)
{
_listener.Stop();
}
_listener = null;
}
}