void _createAccountView_CreateAccountEvent(string userName, string password)
{
AMessageData signupMessageData = new SignUpMessageData(userName, password);
Common.Protocol.Message signupMessage = new Common.Protocol.Message(new MessageHeader(Common.ServiceTypes.SIGNUP), signupMessageData);
_signUpAlreadySent = true;
_outputMessagesList.Add(signupMessage);
}
/// <summary>
/// Dispatches a message to listening clients
/// </summary>
/// <param name="message"></param>
public void DispatchMessage(Message message) {
this.EnsureNotDisposed();
this._messageEventDispatcher.DispatchSending(
new MessageEvent(message));
List<TcpMessageSinkClientConnection> connections;
lock (this._connections) {
connections = this._connections.ToList();
}
foreach (TcpMessageSinkClientConnection connection in connections) {
connection.DispatchMessage(message);
}
}
/// <summary>
/// Merges a pair of messages together or returns null <c>null</c> if merging is not possible
/// </summary>
/// <param name="one"></param>
/// <param name="two"></param>
/// <returns></returns>
public Message FilterTwo(Message one, Message two) {
QueryMessage firstQueryMessage = one as QueryMessage;
QueryMessage secondQueryMessage = two as QueryMessage;
if (firstQueryMessage == null || secondQueryMessage == null) {
return null;
}
if (!AreQueriesEqual(firstQueryMessage.Query, secondQueryMessage.Query)) {
return null;
}
List<QueryMessage> queryMessages = new List<QueryMessage>(new[]{firstQueryMessage, secondQueryMessage});
FlattenExistingDuplicateQueryMessages(queryMessages);
return CreateGroupQuery(queryMessages);
}
/// <summary>
/// Returns the real message data for the received message.
/// </summary>
public static AMessageData GetMessageData(Message mes)
{
switch (mes._header.ServiceType)
{
case ServiceTypes.ACK:
return new AckMessageData(mes._data);
case ServiceTypes.NACK:
return new NackMessageData(mes._data);
case ServiceTypes.PING:
return new PingMessageData(mes._data);
case ServiceTypes.CONNECTION_DATA:
return new ConnectionDataMessageData(mes._data);
case ServiceTypes.CONNECTION_REQ:
return new ConnectionDataRequestedMessageData(mes._data);
case ServiceTypes.USER_LIST:
return new UserListMessageData(mes._data);
case ServiceTypes.USER_CONNECTED:
return new UserConnectedMessageData(mes._data);
case ServiceTypes.USER_DISCONNECTED:
return new UserDisconnectedMessageData(mes._data);
case ServiceTypes.SIGNUP:
return new SignUpMessageData(mes._data);
case ServiceTypes.FILE_TRANSFER_GET:
return new FileTransferGetMessageData(mes._data);
case ServiceTypes.FILE_TRANSFER_SEND:
return new FileTransferSendMessageData(mes._data);
case ServiceTypes.LOGIN:
return new LoginMessageData(mes._data);
case ServiceTypes.LOGOUT:
return new LogoutMessageData(mes._data);
case ServiceTypes.TEXT:
return new TextMessageData(mes._data);
case ServiceTypes.FILE_LIST_GET:
return new FileListGetMessageData(mes._data);
case ServiceTypes.ADD_CONTACT:
return new AddContactMessageData(mes._data);
case ServiceTypes.REMOVE_CONTACT:
return new RemoveContactMessageData(mes._data);
case ServiceTypes.STATUS:
return new StatusMessageData(mes._data);
case ServiceTypes.DISCONNECT:
return new DisconnectMessageData(mes._data);
case ServiceTypes.REMOVE_GROUP:
return new RemoveGroupMessageData(mes._data);
}
throw new UnknownServiceException();
}
private void HandleRequestFile(Socket connectedSocket, Message recMessage)
{
PeerClientData clientData = _connectedClients[connectedSocket];
if (clientData.Socket == connectedSocket)
{
FileTransferGetMessageData messageData = (FileTransferGetMessageData)Message.GetMessageData(recMessage);
clientData.FileId = messageData.Id;
OnRequestFile(clientData.UserName, clientData.FileId, connectedSocket);
}
}
private bool StopThread()
{
_toBreak = true;
foreach (KeyValuePair<Socket, PeerClientData> dataPair in _receiverTransfers)
{
if (dataPair.Value.Socket != null)
{
NackMessageData messageData = new NackMessageData();
Message message = new Message(new MessageHeader(ServiceTypes.NACK), messageData);
dataPair.Value.Socket.Send(message.Serialize());
dataPair.Value.Socket.Close();
if (dataPair.Value.FileStream != null)
{
dataPair.Value.FileStream.Close();
}
}
}
foreach (KeyValuePair<Socket, PeerClientData> dataPair in _connectedClients)
{
if (dataPair.Value.Socket != null)
{
NackMessageData messageData = new NackMessageData();
Message message = new Message(new MessageHeader(ServiceTypes.NACK), messageData);
dataPair.Value.Socket.Send(message.Serialize());
dataPair.Value.Socket.Close();
if (dataPair.Value.FileStream != null)
{
dataPair.Value.FileStream.Close();
}
}
}
_listenSocket.Close();
return true;
}
private static void DispatchMessageInternal(Message message, IMessageSerializer messageSerializer) {
messageSerializer.SerializeMessage(message);
}
void mainView_RemoveContactEvent(string username)
{
if (!(currentState is StateIdle))
return;
IDictionary<string,IList<UserListEntry>> contactsByGroups = ((StateIdle)currentState).ContactsByGroups;
foreach(KeyValuePair<string,IList<UserListEntry>> pair in contactsByGroups)
{
bool found = false;
foreach (UserListEntry entry in pair.Value)
{
if (entry.UserName == username)
{
found = true;
pair.Value.Remove(entry);
break;
}
}
if(found)
break;
}
AMessageData messageData = new RemoveContactMessageData(this.currentUserName, username);
Common.Protocol.Message removeContactMessage = new Common.Protocol.Message(new MessageHeader(Common.ServiceTypes.REMOVE_CONTACT), messageData);
this.outputMessageQueue.Enqueue(removeContactMessage);
mainView.RemoveContact(username);
if (fileTransferView != null && ((StateIdle)currentState).OnlineContacts.ContainsKey(username))
{
fileTransferView.RemoveContact(username);
}
}
void mainView_ChangeContactGroupEvent(string contact, string newgroup)
{
if (!(currentState is StateIdle))
return;
AMessageData messageData = new AddContactMessageData(this.currentUserName, newgroup, contact);
Common.Protocol.Message changeContactGroupMessage = new Common.Protocol.Message(new MessageHeader(Common.ServiceTypes.ADD_CONTACT), messageData);
outputMessageQueue.Enqueue(changeContactGroupMessage);
foreach(KeyValuePair<string,IList<UserListEntry>> pair in ((StateIdle)currentState).ContactsByGroups)
{
if (pair.Key == newgroup)
continue;
foreach (UserListEntry entry in pair.Value)
{
if (entry.UserName == contact)
{
pair.Value.Remove(entry);
((StateIdle)currentState).ContactsByGroups[newgroup].Add(entry);
return;
}
}
}
}
private void MainLoop()
{
if (!CreateServerConnection())
{
mainLoopStarted = false;
toBreak = false;
ForceEmptyOutputQueue();
return;
}
StartPeerConnectionManager();
while (true)
{
Application.DoEvents();
if (toBreak)
{
toBreak = false;
mainLoopStarted = false;
break;
}
if (serverSocket.Poll(1, SelectMode.SelectRead))
{
try
{
byte[] headerBuffer = new byte[MessageHeader.HEADER_SIZE];
int n = serverSocket.Receive(headerBuffer);
ushort contentLength = AMessageData.ToShort(headerBuffer[MessageHeader.HEADER_SIZE - 2], headerBuffer[MessageHeader.HEADER_SIZE - 1]);
byte[] rawData = new byte[contentLength];
if (contentLength > 0)
{
n = serverSocket.Receive(rawData);
}
byte[] messageBuffer = new byte[headerBuffer.Length + contentLength];
Array.Copy(headerBuffer, messageBuffer, headerBuffer.Length);
Array.Copy(rawData, 0, messageBuffer, headerBuffer.Length, contentLength);
Common.Protocol.Message newMessage = new Common.Protocol.Message(messageBuffer);
inputMessageQueue.Enqueue(newMessage);
}
catch (SocketException ex)
{
HandleSocketException();
}
}
ProcessInputQueue();
Application.DoEvents();
if (serverSocket.Poll(1, SelectMode.SelectWrite))
{
ProcessOutputQueue();
}
}
CloseServerConnection();
}
void mainView_LoginEvent(string userName, string password)
{
AMessageData loginMessageData = new LoginMessageData(userName, password, DefaultStatuses.AVAILABLE );
Common.Protocol.Message message = new Common.Protocol.Message(new MessageHeader(Common.ServiceTypes.LOGIN), loginMessageData);
_outputMessagesList.Add(message);
_signInAlreadySent = true;
_userName = userName;
}
private void HandleHelloMessage(Socket connectedSocket, Message recMessage)
{
HelloMessageData messageData = (HelloMessageData)Message.GetMessageData(recMessage);
PeerClientData data = _connectedClients[connectedSocket];
if (data.Socket == connectedSocket)
{
data.UserName = messageData.UserName;
}
}
private IDictionary<int, string> GetFileListFromPeer(string contact, string address, ushort port)
{
try
{
Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
clientSocket.Connect(new IPAddress(Dns.Resolve(address).AddressList[0].Address), port);
Message message = new Message(new MessageHeader(ServiceTypes.FILE_LIST_GET), new FileListGetMessageData(new byte[] { 0, 0, 0, 0 }));
clientSocket.Send(message.Serialize());
byte[] headerBuffer = new byte[MessageHeader.HEADER_SIZE];
clientSocket.Receive(headerBuffer);
ushort contentLen = AMessageData.ToShort(headerBuffer[MessageHeader.HEADER_SIZE - 2], headerBuffer[MessageHeader.HEADER_SIZE - 1]);
byte[] rawData = new byte[contentLen];
clientSocket.Receive(rawData);
byte[] buffer = new byte[headerBuffer.Length + contentLen];
Array.Copy(headerBuffer, buffer, headerBuffer.Length);
Array.Copy(rawData, 0, buffer, headerBuffer.Length, rawData.Length);
FileListGetMessageData messageData = (FileListGetMessageData)Message.GetMessageData(new Message(buffer));
return messageData.FileList;
}
catch (SocketException ex)
{
return new Dictionary<int, string>();
}
}
private void CancelFileTransfer(string contactName, int fileId)
{
lock (_receiverTransfers)
{
foreach (KeyValuePair<Socket, PeerClientData> clientDataPair in _receiverTransfers)
{
if (clientDataPair.Value.UserName == contactName && clientDataPair.Value.FileId == fileId)
{
NackMessageData messageData = new NackMessageData();
Message message = new Message(new MessageHeader(ServiceTypes.NACK), messageData);
clientDataPair.Value.Socket.Send(message.Serialize());
clientDataPair.Value.Socket.Close();
_receiverTransfers.Remove(clientDataPair.Value.Socket);
clientDataPair.Value.FileStream.Close();
break;
}
}
}
}
private void SendConnectionDataResponse(ConnectionDataRequestedMessageData receivedMessageData)
{
AMessageData messageData = new ConnectionDataMessageData(this._userName, receivedMessageData.SenderUserName, this._ip, this._port);
Common.Protocol.Message response = new Common.Protocol.Message(new MessageHeader(ServiceTypes.CONNECTION_DATA), messageData);
_outputMessagesList.Add(response);
}
private void HandlePingMessage()
{
Common.Protocol.Message response = new Common.Protocol.Message(new MessageHeader(ServiceTypes.PING), new PingMessageData());
_outputMessagesList.Add(response);
}
public override AState MoveState()
{
ClearCurrentEventHandlers();
AState newState = new StateInitial();
newState.MainView = _mainView;
newState.ConversationControllers = _conversationControllers;
ToCloseConnection = true;
AMessageData messageData = new LogoutMessageData(this._userName);
Common.Protocol.Message signoutMessage = new Common.Protocol.Message(new MessageHeader(ServiceTypes.LOGOUT), messageData);
newState.OutputMessagesList.Add(signoutMessage);
return newState;
}
private void HandleRequestFileList(Socket connectedSocket, Message recMessage)
{
PeerClientData clietnData = _connectedClients[connectedSocket];
if (clietnData.Socket == connectedSocket)
{
clietnData.FileId = _fileListId;
clietnData.LocalPath = "";
clietnData.Alias = "";
OnRequestFileList(clietnData.UserName, connectedSocket);
}
}
private void HandleRequests()
{
ArrayList readSocks = new ArrayList();
foreach (KeyValuePair<Socket, PeerClientData> dataPair in _connectedClients)
{
if (dataPair.Value.Socket.Connected)
readSocks.Add(dataPair.Value.Socket);
}
if (readSocks.Count == 0)
return;
Socket.Select(readSocks, null, null, 1);
for (int i = 0; i < readSocks.Count; i++)
{
Socket connectedSocket = (Socket)readSocks[i];
byte[] header = new byte[MessageHeader.HEADER_SIZE];
int cnt;
try
{
cnt = connectedSocket.Receive(header);
}
catch (SocketException ex)
{
HandleCancelTransfer(connectedSocket);
continue;
}
if (cnt != MessageHeader.HEADER_SIZE)
continue;
ushort contentLength = AMessageData.ToShort(header[MessageHeader.HEADER_SIZE - 2], header[MessageHeader.HEADER_SIZE - 1]);
byte[] rawdata = new byte[contentLength];
if (contentLength > 0)
{
cnt = connectedSocket.Receive(rawdata);
if (cnt != (int)contentLength)
continue;
}
byte[] message = new byte[MessageHeader.HEADER_SIZE + rawdata.Length];
Array.Copy(header, message, header.Length);
Array.Copy(rawdata, 0, message, header.Length, rawdata.Length);
Message recMessage = new Message(message);
switch (recMessage.Header.ServiceType)
{
case ServiceTypes.FILE_LIST_GET:
HandleRequestFileList(connectedSocket, recMessage);
return;
case ServiceTypes.FILE_TRANSFER_GET:
HandleRequestFile(connectedSocket, recMessage);
return;
case ServiceTypes.NACK:
HandleCancelTransfer(connectedSocket);
return;
case ServiceTypes.HELLO:
HandleHelloMessage(connectedSocket, recMessage);
return;
}
}
}
void fileTransferView_GetContactListEvent(string contact)
{
if (((StateIdle)currentState).MadeConnectionRequests.ContainsKey(contact))
{
ConnectionDataMessageData data = ((StateIdle)currentState).MadeConnectionRequests[contact];
IDictionary<int, string> receivedFileList = peerConnectionManager.getFileListFromPeerDelegate.Invoke(contact, data.IpAddress, data.Port);
_downloadedFileLists[contact] = receivedFileList;
}
else
{
AMessageData messageData = new ConnectionDataRequestedMessageData(this.currentUserName, contact);
Common.Protocol.Message connDataMessage = new Common.Protocol.Message(new MessageHeader(ServiceTypes.CONNECTION_REQ), messageData);
this.outputMessageQueue.Enqueue(connDataMessage);
((StateIdle)currentState).PendingConnectionRequests.Add(new KeyValuePair<string, ConnectionDataMessageData>(contact, null));
return;
}
IDictionary<int, string> fileList = _downloadedFileLists[contact];
IList<string> toReturn = new List<string>();
foreach (KeyValuePair<int, string> pair in fileList)
{
toReturn.Add(pair.Value);
}
fileTransferView.LoadList(contact, toReturn);
}
private void ReceiveData()
{
ArrayList receiverSockets = new ArrayList();
inIteration = true;
foreach (KeyValuePair<Socket, PeerClientData> dataPair in _receiverTransfers)
{
if (dataPair.Value.FileStream == null)
{
dataPair.Value.FileStream = new FileStream(dataPair.Value.Alias, FileMode.OpenOrCreate);
AMessageData requestMessageData = new FileTransferGetMessageData(dataPair.Value.FileId);
Message toSend = new Message(new MessageHeader(ServiceTypes.FILE_TRANSFER_GET), requestMessageData);
dataPair.Value.Socket.Send(toSend.Serialize());
}
if(dataPair.Value.Socket.Connected)
receiverSockets.Add(dataPair.Value.Socket);
}
inIteration = false;
if (receiverSockets.Count == 0)
return;
Socket.Select(receiverSockets, null, null, 1);
for (int i = 0; i < receiverSockets.Count; i++)
{
SaveFileBuffer((Socket)receiverSockets[i]);
}
}
void mainView_AddContactEvent(string uname, string group)
{
if (!(currentState is StateIdle))
return;
if (AState.CheckIfContactExists(uname,((StateIdle)currentState).ContactsByGroups))
{
ErrorHandler.HandleError("Contact already in contacts list!", "Error", (IWin32Window)mainView);
return;
}
AMessageData messageData = new AddContactMessageData(this.currentUserName, group, uname);
Common.Protocol.Message addContactMessage = new Common.Protocol.Message(new MessageHeader(Common.ServiceTypes.ADD_CONTACT), messageData);
this.outputMessageQueue.Enqueue(addContactMessage);
((StateIdle)currentState).ContactsByGroups[group].Add(new UserListEntry(uname));
mainView.AddContact(uname, group);
if (fileTransferView != null && ((StateIdle)currentState).OnlineContacts.ContainsKey(uname))
{
fileTransferView.AddContact(uname);
}
}
private void RequestedFileList(IDictionary<int, string> fileList, Socket contactSocket)
{
FileListGetMessageData messageData = new FileListGetMessageData(fileList);
Message newMessage = new Message(new MessageHeader(ServiceTypes.FILE_LIST_GET), messageData);
contactSocket.Send(newMessage.Serialize());
PeerClientData data = _connectedClients[contactSocket];
data.FileId = -1;
_connectedClients.Remove(contactSocket);
data.Socket.Close();
}
void mainView_ChangeStatusEvent(string status)
{
AMessageData messageData = new StatusMessageData(this.currentUserName, status);
Common.Protocol.Message changeStatusMessage = new Common.Protocol.Message(new MessageHeader(Common.ServiceTypes.STATUS), messageData);
this.outputMessageQueue.Enqueue(changeStatusMessage);
}
private void SaveFileBuffer(Socket receiverSocket)
{
PeerClientData data = _receiverTransfers[receiverSocket];
byte[] messageBuffer = new byte[MessageHeader.HEADER_SIZE];
int currentReceived = 0;
while (currentReceived != MessageHeader.HEADER_SIZE)
{
int lastReceived;
try
{
lastReceived = data.Socket.Receive(messageBuffer, currentReceived, MessageHeader.HEADER_SIZE - currentReceived, SocketFlags.None);
}
catch (SocketException ex)
{
data.FileStream.Close();
_receiverTransfers.Remove(data.Socket);
OnCancelTransfer(data.UserName, data.FileId);
return;
}
catch (ObjectDisposedException ex)
{
data.FileStream.Close();
_receiverTransfers.Remove(data.Socket);
OnCancelTransfer(data.UserName, data.FileId);
return;
}
currentReceived += lastReceived;
}
Message recMessage = new Message(messageBuffer);
switch (recMessage.Header.ServiceType)
{
case ServiceTypes.FILE_TRANSFER_SEND:
ushort contentLen = AMessageData.ToShort(messageBuffer[MessageHeader.HEADER_SIZE - 2], messageBuffer[MessageHeader.HEADER_SIZE - 1]);
byte[] rawData = new byte[contentLen];
currentReceived = 0;
while (currentReceived != contentLen)
{
try
{
int lastReceived = data.Socket.Receive(rawData, currentReceived, contentLen - currentReceived, SocketFlags.None);
currentReceived += lastReceived;
}
catch (ObjectDisposedException ex)
{
data.FileStream.Close();
_receiverTransfers.Remove(data.Socket);
OnCancelTransfer(data.UserName, data.FileId);
return;
}
}
lock (data.FileStream)
{
data.FileStream.Write(rawData, 2 * sizeof(Int32), rawData.Length - 2 * sizeof(Int32));
}
if (rawData.Length < FileTransferSendMessageData.MAX_MESSAGE_SIZE)
{
data.FileStream.Close();
data.Socket.Close();
_receiverTransfers.Remove(data.Socket);
OnTransferEnded(data.UserName, data.FileId);
}
else
{
data.ReadBytes += rawData.Length;
double speed = (double)data.ReadBytes / (double)(DateTime.Now.Ticks - data.LastTimeStamp.Ticks);
//transform in Bytes/s
speed *= Math.Pow((double)10, (double)7);
//transform in KiloBytes/s
speed /= 1024;
if (double.IsInfinity(speed))
speed = double.MaxValue;
int fileLength = AMessageData.ToInt(rawData, sizeof(Int32));
OnProgressChanged(data.UserName, data.FileId, (int)((float)data.ReadBytes / (float)fileLength * 100), (float)speed);
}
break;
case ServiceTypes.NACK:
data.FileStream.Close();
data.Socket.Close();
_receiverTransfers.Remove(data.Socket);
OnCancelTransfer(data.UserName, data.FileId);
break;
}
}
void mainView_RemoveGroupEvent(string group)
{
if (!(currentState is StateIdle))
return;
IList<UserListEntry> groupList = ((StateIdle)currentState).ContactsByGroups[group];
if (groupList.Count > 0)
{
ErrorHandler.HandleError("Cannot delete group! The group is not empty!", "Error", (IWin32Window)mainView);
return;
}
((StateIdle)currentState).ContactsByGroups.Remove(group);
AMessageData messageData = new RemoveGroupMessageData(this.currentUserName, group);
Common.Protocol.Message message = new Common.Protocol.Message(new MessageHeader(ServiceTypes.REMOVE_GROUP), messageData);
this.outputMessageQueue.Enqueue(message);
mainView.RemoveGroup(group);
}
public void DispatchMessage(Message message) {
this.EnsureNotDisposed();
ThreadPool.QueueUserWorkItem(this.DispatchMessageInternal, message);
}
