[B]Chat Server:[/B]
ChatServer.cs
[code]
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
using System.Collections;
using System.Windows.Forms;
using System.Security.Cryptography;
namespace ChatServer
{
// Holds the arguments for the StatusChanged event
public class StatusChangedEventArgs: EventArgs
{
// The argument we're interested in is a message describing the event
private string EventMsg;
// Property for retrieving and setting the event message
public string EventMessage
{
get
{
return EventMsg;
}
set
{
EventMsg = value;
}
}
// Constructor for setting the event message
public StatusChangedEventArgs(string strEventMsg)
{
EventMsg = strEventMsg;
}
}
// This delegate is needed to specify the parameters we're passing with our event
public delegate void StatusChangedEventHandler(object sender, StatusChangedEventArgs e);
class ChatServer
{
// This hash table stores users and connections (browsable by user)
public static Hashtable htUsers = new Hashtable(30); // 30 users at one time limit
// This hash table stores connections and users (browsable by connection)
public static Hashtable htConnections = new Hashtable(30); // 30 users at one time limit
// 30 Users keys
public static Hashtable htClientPublicKeys = new Hashtable(30);
public static Hashtable htServerPublicKeys = new Hashtable(30);
public static Hashtable htServerPrivateKeys = new Hashtable(30);
// Will store the IP address passed to it
private IPAddress ipAddress;
private TcpClient tcpClient;
// The event and its argument will notify the form when a user has connected, disconnected, send message, etc.
public static event StatusChangedEventHandler StatusChanged;
private static StatusChangedEventArgs e;
// The constructor sets the IP address to the one retrieved by the instantiating object
public ChatServer(IPAddress address)
{
ipAddress = address;
}
// The thread that will hold the connection listener
private Thread thrListener;
// The TCP object that listens for connections
private TcpListener tlsClient;
// Will tell the while loop to keep monitoring for connections
bool ServRunning = false;
// Add the user to the hash tables
public static String AddUser(TcpClient tcpUser, string strUsername, string clientPublicKey)
{
// First add the username and associated connection to both hash tables
ChatServer.htUsers.Add(strUsername, tcpUser);
ChatServer.htConnections.Add(tcpUser, strUsername);
RSACryptoServiceProvider rsaServerKeysToken = new RSACryptoServiceProvider(2048);
ChatServer.htClientPublicKeys.Add(tcpUser, clientPublicKey);
ChatServer.htServerPublicKeys.Add(tcpUser, rsaServerKeysToken.ToXmlString(false));
ChatServer.htServerPrivateKeys.Add(tcpUser, rsaServerKeysToken.ToXmlString(true));
// Tell of the new connection to all other users and to the server form
return rsaServerKeysToken.ToXmlString(false);
}
// Remove the user from the hash tables
public static void RemoveUser(TcpClient tcpUser)
{
// If the user is there
if ((String)ChatServer.htConnections[tcpUser] != null)
{
String tcpUserName = (String)ChatServer.htConnections[tcpUser];
//MessageBox.Show(null, tcpUserName, «Server F# RemoveUser M# Has left»);// Remove the user from the hash table
ChatServer.htUsers.Remove(ChatServer.htConnections[tcpUser]);
ChatServer.htConnections.Remove(tcpUser);
ChatServer.htClientPublicKeys.Remove(tcpUser);
ChatServer.htServerPublicKeys.Remove(tcpUser);
ChatServer.htServerPrivateKeys.Remove(tcpUser);
// First show the information and tell the other users about the disconnection
SendAdminMessage(tcpUserName + " has left us");
}
}
// This is called when we want to raise the StatusChanged event
public static void OnStatusChanged(StatusChangedEventArgs e)
{
StatusChangedEventHandler statusHandler = StatusChanged;
if (statusHandler != null)
{
// Invoke the delegate
statusHandler(null, e);
}
}
// Send administrative messages
public static void SendAdminMessage(string Message)
{
StreamWriter swSenderSender;
// First of all, show in our application who says what
e = new StatusChangedEventArgs(«Administrator: » + Message);
OnStatusChanged(e);
// Create an array of TCP clients, the size of the number of users we have
TcpClient[] tcpClients = new TcpClient[ChatServer.htUsers.Count];
// Copy the TcpClient objects into the array
ChatServer.htUsers.Values.CopyTo(tcpClients, 0);
// Loop through the list of TCP clients
String[] clientKeyToken = new String[ChatServer.htClientPublicKeys.Count];
// Copy the TcpClient objects into the array
ChatServer.htClientPublicKeys.Values.CopyTo(clientKeyToken, 0);
for (int i = 0; i < tcpClients.Length; i++)
{
// Try sending a message to each
try
{
// If the message is blank or the connection is null, break out
if (Message.Trim() == "" || tcpClients == null)
{
RemoveUser(tcpClients);
//ChatServer.htUsers.Values.CopyTo(tcpClients, 0);
// Loop through the list of TCP clients
//clientKeyToken = new String[ChatServer.htClientPublicKeys.Count];
// Copy the TcpClient objects into the array
// ChatServer.htClientPublicKeys.Values.CopyTo(clientKeyToken, 0);
continue;
}
RSACryptoServiceProvider rsaCryptKeyMessage = new RSACryptoServiceProvider(2048);
rsaCryptKeyMessage.FromXmlString(clientKeyToken);
UTF8Encoding utf8 = new UTF8Encoding();
//String encryptedMessage = Convert.ToBase64String(rsaCryptKeyMessage.Encrypt(utf8.GetBytes(«Administrator: » + Message.Trim()), false));
// Send the message to the current user in the loop
swSenderSender = new StreamWriter(tcpClients.GetStream());
swSenderSender.WriteLine(Convert.ToBase64String(rsaCryptKeyMessage.Encrypt(utf8.GetBytes(«Administrator: » + Message.Trim()), false)));
swSenderSender.Flush();
swSenderSender = null;
}
catch // If there was a problem, the user is not there anymore, remove him
{
RemoveUser(tcpClients);
//ChatServer.htUsers.Values.CopyTo(tcpClients, 0);
// Loop through the list of TCP clients
//clientKeyToken = new String[ChatServer.htClientPublicKeys.Count];
// Copy the TcpClient objects into the array
//ChatServer.htClientPublicKeys.Values.CopyTo(clientKeyToken, 0);
}
}
}
// Send messages from one user to all the others
public static void SendMessage(string From, string msg)
{
StreamWriter swSenderSender;
// First of all, show in our application who says what
// Create an array of TCP clients, the size of the number of users we have
TcpClient[] tcpClients = new TcpClient[ChatServer.htUsers.Count];
// Copy the TcpClient objects into the array
ChatServer.htUsers.Values.CopyTo(tcpClients, 0);
String[] clientKeyToken = new String[ChatServer.htClientPublicKeys.Count];
// Copy the TcpClient objects into the array
ChatServer.htClientPublicKeys.Values.CopyTo(clientKeyToken, 0);
// Loop through the list of TCP clients
UTF8Encoding utf8 = new UTF8Encoding();
RSACryptoServiceProvider rsaClientMsg = new RSACryptoServiceProvider(2048);
rsaClientMsg.FromXmlString ((String)ChatServer.htServerPrivateKeys[ChatServer.htUsers[From]]);
msg = utf8.GetString(rsaClientMsg.Decrypt(Convert.FromBase64String(msg), false));
e = new StatusChangedEventArgs(From + " says: " + msg);
OnStatusChanged(e);
for (int i = 0; i < tcpClients.Length; i++)
{
// Try sending a message to each
try
{
// If the message is blank or the connection is null, break out
if (msg.Trim() == "" || tcpClients == null)
{
RemoveUser(tcpClients);
continue;
}
RSACryptoServiceProvider rsaCryptKeyMessage = new RSACryptoServiceProvider(2048);
rsaCryptKeyMessage.FromXmlString(clientKeyToken);
UTF8Encoding utf82 = new UTF8Encoding();
String encryptedMessage = Convert.ToBase64String(rsaCryptKeyMessage.Encrypt(utf82.GetBytes(From + " says: " + msg), false));
// Send the message to the current user in the loop
swSenderSender = new StreamWriter(tcpClients.GetStream());
swSenderSender.WriteLine(encryptedMessage);
swSenderSender.Flush();
swSenderSender = null;
// clientKeyToken = null;
}
catch // If there was a problem, the user is not there anymore, remove him
{
RemoveUser(tcpClients);
}
}
}
public void StartListening()
{
// Get the IP of the first network device, however this can prove unreliable on certain configurations
IPAddress ipaLocal = ipAddress;
// Create the TCP listener object using the IP of the server and the specified port
tlsClient = new TcpListener(1986);
// Start the TCP listener and listen for connections
tlsClient.Start();
// The while loop will check for true in this before checking for connections
ServRunning = true;
// Start the new tread that hosts the listener
thrListener = new Thread(KeepListening);
thrListener.Start();
}
private void KeepListening()
{
// While the server is running
while (ServRunning == true)
{
// Accept a pending connection
tcpClient = tlsClient.AcceptTcpClient();
// Create a new instance of Connection
Connection newConnection = new Connection(tcpClient);
}
}
}
// This class handels connections; there will be as many instances of it as there will be connected users
class Connection
{
TcpClient tcpClient;
// The thread that will send information to the client
private Thread thrSender;
private StreamReader srReceiver;
private StreamWriter swSender;
private string currUser;
private string strResponse;
// The constructor of the class takes in a TCP connection
public Connection(TcpClient tcpCon)
{
tcpClient = tcpCon;
// The thread that accepts the client and awaits messages
thrSender = new Thread(AcceptClient);
// The thread calls the AcceptClient() method
thrSender.Start();
}
private void CloseConnection()
{
// Close the currently open objects
tcpClient.Close();
srReceiver.Close();
swSender.Close();
thrSender.Abort();
}
// Occures when a new client is accepted
private void AcceptClient()
{
srReceiver = new System.IO.StreamReader(tcpClient.GetStream());
swSender = new System.IO.StreamWriter(tcpClient.GetStream());
// Read the account information from the client
currUser = srReceiver.ReadLine();
String[] userResponse = currUser.Split('|');
// We got a response from the client
if (currUser != "")
{
// Store the user name in the hash table
if (ChatServer.htUsers.Contains(userResponse[0]) == true)
{
// 0 means not connected
swSender.WriteLine(«0|This username already exists.»);
swSender.Flush();
CloseConnection();
return;
}
else if (userResponse[0] == «Administrator»)
{
// 0 means not connected
swSender.WriteLine(«0|This username is reserved.»);
swSender.Flush();
CloseConnection();
return;
}
else
{
// Add the user to the hash tables and start listening for messages from him
//MessageBox.Show(null, userResponse[1], userResponse[0]);
String clientKey = ChatServer.AddUser(tcpClient, userResponse[0], userResponse[1]);
// 1 means connected successfully
swSender.WriteLine(«1|» + clientKey);
swSender.Flush();
ChatServer.SendAdminMessage(userResponse[0] + " has joined us");
}
}
else
{
CloseConnection();
return;
}
try
{
// Keep waiting for a message from the user
while ((strResponse = srReceiver.ReadLine()) != "")
{
// If it's invalid, remove the user
if (strResponse == null)
{
ChatServer.RemoveUser(tcpClient);
CloseConnection();
continue;
}
else
{
//MessageBox.Show(null, strResponse, «Server F# AcceptClient M# strResponse»);
// Otherwise send the message to all the other users
ChatServer.SendMessage(userResponse[0], strResponse);
}
}
}
catch
{
// If anything went wrong with this user, disconnect him
ChatServer.RemoveUser(tcpClient);
}
}
}
}
[/code]
Form1.cs
[code]
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using System.IO;
namespace ChatServer
{
public partial class Form1: Form
{
private delegate void UpdateStatusCallback(string strMessage);
public Form1()
{
InitializeComponent();
}
private void btnListen_Click(object sender, EventArgs e)
{
// Parse the server's IP address out of the TextBox
IPAddress ipAddr = IPAddress.Parse(txtIp.Text);
// Create a new instance of the ChatServer object
ChatServer mainServer = new ChatServer(ipAddr);
// Hook the StatusChanged event handler to mainServer_StatusChanged
ChatServer.StatusChanged += new StatusChangedEventHandler(mainServer_StatusChanged);
// Start listening for connections
btnListen.Enabled = false;
mainServer.StartListening();
// Show that we started to listen for connections
txtLog.AppendText(«Monitoring for connections...\r\n»);
}
public void mainServer_StatusChanged(object sender, StatusChangedEventArgs e)
{
//// Call the method that updates the form
this.Invoke(new UpdateStatusCallback(this.UpdateStatus), new object[] { e.EventMessage });
}
private void UpdateStatus(string strMessage)
{
// Updates the log with the message
txtLog.AppendText(strMessage + "\r\n");
}
private void btnStopListen_Click(object sender, EventArgs e)
{
// mainServer.StopListening();
}
}
}
[/code]
Program.cs
[code]
using System;
using System.Collections.Generic;
using System.Windows.Forms;
namespace ChatServer
{
static class Program
{
/// /// The main entry point for the application.
///
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
}
[/code]