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); }