void HandleData(int connectionId, int channelId, int receivedSize, NetworkError error) { var client = FindConnection(connectionId); if (client == null) { return; } client.LastError = error; #if NETWORK_DEBUGGER_ENABLED var logMessage = new System.Text.StringBuilder("ServerPeer"); logMessage.Append(" Incoming"); logMessage.Append(" ConnectionId:").Append(connectionId); logMessage.Append(" ChannelId:").Append(channelId); logMessage.Append(" Size:").Append(receivedSize); UnityEngine.Debug.Log(logMessage); #endif #if NETWORK_PROFILER_ENABLED && UNITY_EDITOR var profilerName = new System.Text.StringBuilder("ServerPeer"); profilerName.Append(channelId); Profiler.NetworkProfiler.RecordChannelIncoming(profilerName.ToString(), (ushort)receivedSize); #endif if (DataEvent != null) { DataEvent.Invoke(client, channelId, m_RecievedBuffer, receivedSize); } }
void HandleConnectingFailedEvent(NetworkError error) { if (ConnectingFailedEvent != null) { ConnectingFailedEvent.Invoke(error); } }
public bool Connect(out NetworkError error) { Disconnect = false; ProcessWorkers = new Thread[workerProcessCount]; // Create and start a separate thread for each worker for (int i = 0; i < workerProcessCount; i++) { ProcessWorkers[i] = new Thread(MessagesConsumer); ProcessWorkers[i].Name = "LLApi Process Thread " + i; ProcessWorkers[i].Start(); } SocketId = NetworkTransport.AddHost(Topology); byte errorByte; ConnectionId = NetworkTransport.Connect(SocketId, EndPoint, Port, 0, out errorByte); error = (NetworkError)errorByte; if (error != NetworkError.Ok) { isConnecting = false; isConnected = false; Debug.LogError("LLApiClient Error Connecting to " + EndPoint + ":" + Port + " Error: " + error); } else { isConnecting = true; Debug.Log("LLApiClient Connecting to " + EndPoint + ":" + Port + " ConnectionId : " + ConnectionId + "SocketID : "+SocketId); } return isConnecting; }
public void AddNetworkListeners(NetworkConnected netConCall, DataSent dataSentCall, DataReceived dataRecvCall, NetworkError netErrorCall) { OnNetworkConnected += netConCall; OnDataSent += dataSentCall; OnDataReceived += dataRecvCall; OnNetworkError += netErrorCall; }
void OnError(NetworkConnection conn, NetworkError netError) { if (netError == NetworkError.Timeout) { Connect(); } }
//This function is called when data is sent void OnData(int hostId, int connectionId, int channelId, byte[] data, int size, NetworkError error) { //Here the message being received is deserialized and output to the console Stream serializedMessage = new MemoryStream(data); BinaryFormatter formatter = new BinaryFormatter(); string message = formatter.Deserialize(serializedMessage).ToString(); Debug.Log(message); string[] splitString = message.Split(','); if (splitString.Length < 1) { Debug.LogError("ThisShould not happen I need more infor to change the screen"); } if (splitString[0].Equals("i")) { OnInitConsole(int.Parse(splitString[1])); } else if (splitString[0].Equals("s")) { OnSelectCar(int.Parse(splitString[1])); } else { Debug.Log("I got something I am not sure if that works"); } //Output the deserialized message as well as the connection information to the console Debug.Log("OnData(hostId = " + hostId + ", connectionId = " + connectionId + ", channelId = " + channelId + ", data = " + message + ", size = " + size + ", error = " + error.ToString() + ")"); }
void OnData(int hostId, int connectionId, int channelId, int size, NetworkError error) { //Output the deserialized message as well as the connection information to the console Debug.Log("OnData(hostId = " + hostId + ", connectionId = " + connectionId + ", channelId = " + channelId + ", size = " + size + ", error = " + error.ToString() + ")"); }
//Inizializzazione Client, richiesta connessione al host. //Il client si collega al host all'indirizzo IP e Port definito. //Una volta collegato rimane in attesa di avvenuta connessione per poi richiedere la richiesta di partecipazione al "Party" public void StartClienting(string hostIP, int port) { _isServer = false; _isStarted = true; NetworkTransport.Init(); this.hostIP = hostIP; this.port = port; _myIp = GetLocalIPAddress(); commandsSent = 0; commandsReceived = 0; _genericHostId = NetworkTransport.AddHost(new HostTopology(_config, 24), 0); //? byte error; _connectionID = NetworkTransport.Connect(_genericHostId, hostIP, port, 0, out error); NetworkError nError = (NetworkError)error; if (nError != NetworkError.WrongChannel) { Debug.LogError(nError.ToString()); _lastMessageError = nError.ToString(); } }
public bool SendCommand(BaseCommand command) { if (!_isStarted) { return(false); } byte error; byte[] bytes = Encoding.UTF32.GetBytes(JsonUtility.ToJson(command)); NetworkTransport.Send(_hostID, command.idReceiver, _communicationChannel, bytes, bytes.Length, out error); NetworkError nError = (NetworkError)error; if (nError != NetworkError.Ok) { Debug.LogError(nError.ToString()); _lastMessageError = nError.ToString() + " HID:" + _hostID + " RID:" + command.idReceiver + " CH" + _communicationChannel; NetworkTransport.Send(_hostID, command.idReceiver, _communicationChannel == 0 ? 1 : 0, bytes, bytes.Length, out error); //Remove this return(false); } _lastMessageError = nError.ToString() + " HID:" + _hostID + " RID:" + command.idReceiver + " CH" + _communicationChannel; _lastCommandSent = command.commandType; commandsSent++; return(true); }
private void ErrorHandler(NetworkMessage netMsg) { ErrorMessage errorMsg = netMsg.ReadMessage <ErrorMessage>(); NetworkError error = (NetworkError)errorMsg.errorCode; Debug.LogError("Network Error: " + error); }
public override void JoinGame(object serverAddress, OnJoinGameDelegate callback) { Application.runInBackground = true; NetworkTransport.Init(); ConnectionConfig connectionConfig = new ConnectionConfig(); reliableChannelId = connectionConfig.AddChannel(QosType.Reliable); unreliableChannelId = connectionConfig.AddChannel(QosType.Unreliable); HostTopology topology = new HostTopology(connectionConfig, 4); hostId = NetworkTransport.AddHost(topology); if (hostId < 0) { callback(null, "Server socket creation failed!"); return; } serverConnectionId = NetworkTransport.Connect(hostId, (string)serverAddress, 8888, 0, out byte error); if (error != 0) { NetworkError networkError = (NetworkError)error; callback(null, "Error: " + networkError.ToString()); } else { callback(serverConnectionId, null); } }
public void Connect(string address, int port) { var topology = new HostTopology(_connectionConfig, 1); _socketId = NetworkTransport.AddHost(topology); byte error; _connectionId = NetworkTransport.Connect(_socketId, address, port, 0, out error); NetworkError errorType = (NetworkError)error; if (errorType == NetworkError.Ok) { Debug.Log("Connected to server. Connection id: " + _connectionId); if (OnConnectedToServer != null) { OnConnectedToServer.Invoke(); } } else { Debug.LogError("Connection failed with errorType: " + _connectionId); if (OnConnectionFail != null) { OnConnectionFail.Invoke(errorType.ToString()); } } }
public void Host_SendCommand_ToParty(BaseCommand baseCommand) { if (!_isStarted) { return; } if (!_isServer) { return; } baseCommand.idSender = _connectionID; baseCommand.ipSender = MyIP; foreach (int id in _partyIDs) { byte error; byte[] bytes = Encoding.UTF32.GetBytes(JsonUtility.ToJson(baseCommand)); NetworkTransport.Send(_hostID, id, _communicationChannel, bytes, bytes.Length, out error); NetworkError nError = (NetworkError)error; if (nError != NetworkError.Ok) { Debug.LogError(nError.ToString()); _lastMessageError = nError.ToString() + " HID:" + _hostID + " RID:" + id + " CH" + _communicationChannel; } else { _lastCommandSent = baseCommand.commandType; commandsSent++; } } }
public NetEventType PollReceive(out uint clientId, out int channelId, ref byte[] data, int bufferSize, out int receivedSize, out byte error) { NetworkEventType eventType = NetworkTransport.Receive(out int hostId, out int connectionId, out channelId, data, bufferSize, out receivedSize, out byte err); clientId = new NetId((byte)hostId, (ushort)connectionId, false).GetClientId(); NetworkError errorType = (NetworkError)err; if (errorType == NetworkError.Timeout) { eventType = NetworkEventType.DisconnectEvent; //In UNET. Timeouts are not disconnects. We have to translate that here. } error = 0; //Translate NetworkEventType to NetEventType switch (eventType) { case NetworkEventType.DataEvent: return(NetEventType.Data); case NetworkEventType.ConnectEvent: return(NetEventType.Connect); case NetworkEventType.DisconnectEvent: return(NetEventType.Disconnect); case NetworkEventType.Nothing: return(NetEventType.Nothing); case NetworkEventType.BroadcastEvent: return(NetEventType.Nothing); } return(NetEventType.Nothing); }
public void StartClient() { NetworkTransport.Init(); byte error; config = new ConnectionConfig(); config.SendDelay = 0; // hmm reliableSequencedChannelId = config.AddChannel(QosType.ReliableSequenced); // For RPC Input commands like switching teams and of course, PlayerConnect. unreliableChannelId = config.AddChannel(QosType.Unreliable); // All input that goes on a frame per frame basis like moving & shooting hostTopology = new HostTopology(config, 1); hostId = NetworkTransport.AddHost(hostTopology); connectionId = NetworkTransport.Connect(hostId, ip, port, 0, out error); NetworkError networkError = (NetworkError)error; if (networkError != NetworkError.Ok) { Debug.LogError(string.Format("Unable to connect to {0}:{1}, Error: {2}", ip, port, networkError)); } else { OperationNetwork.initialConnected = 0; } Debug.LogError("Connected initial"); }
// MsgType.Error handler // Called on this client when there was a network error void OnClientError(NetworkMessage msg) { int errorCode = msg.ReadMessage <ErrorMessage>().errorCode; NetworkError networkError = (NetworkError)errorCode; Debug.Log("[CLIENT] NetworkMessage : OnClientError - Error address: " + StripIPv6Formatting(msg.conn.address) + "\n NetworkError." + networkError + " (code " + errorCode + ")"); }
private static void TriggerErrorEvent(NetworkError error, string msg) { if (OnNetworkError != null) { OnNetworkError(NetworkError.Login_Failed, "Error Could not login"); } }
protected virtual bool StartClient() { Initialize(); NetworkIdentity[] identities = FindObjectsOfType <NetworkIdentity>(); foreach (NetworkIdentity identity in identities) { Destroy(identity.gameObject); } m_hostID = NetworkTransport.AddHost(m_hostTopology); byte error; m_clientID = NetworkTransport.Connect(m_hostID, m_Address, m_Port, 0, out error); NetworkError networkError = (NetworkError)error; if (networkError != NetworkError.Ok) { Debug.LogError($"Fehler beim Erstellen des Clients! ({networkError})", this); return(false); } m_isServer = false; return(true); }
private void GenerateError(int error) { NetworkError netError = (NetworkError)error; if (LogFilter.logError) { Debug.LogError("Client Net Error: " + netError); } NetworkMessageDelegate msgDelegate = handlers.ContainsKey(MsgType.Error) ? handlers[MsgType.Error] : null; if (msgDelegate != null) { ErrorMessage msg = new ErrorMessage(); msg.errorCode = error; // write the message to a local buffer byte[] errorBuffer = new byte[200]; NetworkWriter writer = new NetworkWriter(errorBuffer); msg.Serialize(writer); // pass a reader (attached to local buffer) to handler NetworkReader reader = new NetworkReader(errorBuffer); NetworkMessage netMsg = new NetworkMessage(); netMsg.msgType = MsgType.Error; netMsg.reader = reader; netMsg.conn = m_myConnection; netMsg.channelId = 0; msgDelegate(netMsg); } }
private bool IsFatalError(NetworkError error) { switch (error) { case NetworkError.WrongHost: case NetworkError.WrongConnection: case NetworkError.WrongChannel: case NetworkError.NoResources: case NetworkError.Timeout: case NetworkError.VersionMismatch: case NetworkError.DNSFailure: case NetworkError.CRCMismatch: case NetworkError.BadMessage: case NetworkError.UsageError: return(true); case NetworkError.Ok: case NetworkError.MessageToLong: case NetworkError.WrongOperation: return(false); default: Log.CreatePossibleBugException(string.Format("Dissonance UNet received unknown NetworkError: '{0}'", error), "BF18ADA4-CDC0-43F6-B99D-DC52E9A991F4"); return(true); } }
/// <summary> /// Sends the specified <see cref="DataMessage"/> to the server. /// </summary> /// <param name="message">The message.</param> /// <param name="channel">The channel.</param> /// <param name="error">The error.</param> /// <returns></returns> protected bool Send(DataMessage message, QosType channel, out NetworkError error) { //Debug.Log(this.ToString() + " Sending message of type: " + message.type.ToString() + " on channel: " + type.ToString()); var buffer = message.Serialize(); return(base.Send(_localConnectionId, buffer, channel, message.GetTotalByteSize(), out error)); }
internal Connection(int socketId, int connectionId, bool isConnected, NetworkError lastError) { SocketId = socketId; ConnectionId = connectionId; IsConnected = isConnected; LastError = lastError; }
private void Start() { // Init Transport using default values. NetworkTransport.Init(); // Create a connection config and add a Channel. ConnectionConfig config = new ConnectionConfig(); channelId = config.AddChannel(QosType.ReliableSequenced); // Create a topology based on the connection config. HostTopology topology = new HostTopology(config, 10); // Create a host based on the topology we just created, and bind the socket to port. hostId = NetworkTransport.AddHost(topology, clientSockedPort); Debug.Log("Socket Open. SocketId is: " + hostId); // Connect to the host with IP and port. byte error; connectionId = NetworkTransport.Connect(hostId, serverAddress, serverSocketPort, 0, out error); NetworkError networkError = (NetworkError)error; if (networkError != NetworkError.Ok) { Debug.LogError($"Unable to connect to {serverAddress}:{serverSocketPort}, Error: {networkError}"); } else { Debug.Log($"Connected to {serverAddress}:{serverSocketPort} with hostId: {hostId}, connectionId: {connectionId}, channelId: {channelId},"); } }
public override SocketTasks StartClient() { SocketTask task = SocketTask.Working; serverHostId = RelayTransport.AddHost(new HostTopology(GetConfig(), 1), false); serverConnectionId = RelayTransport.Connect(serverHostId, ConnectAddress, ConnectPort, 0, out byte error); NetworkError connectError = (NetworkError)error; switch (connectError) { case NetworkError.Ok: task.Success = true; task.TransportCode = error; task.SocketError = System.Net.Sockets.SocketError.Success; task.IsDone = false; // We want to continue to wait for the successful connect connectTask = task; break; default: task.Success = false; task.TransportCode = error; task.SocketError = System.Net.Sockets.SocketError.SocketError; task.IsDone = true; break; } return(task.AsTasks()); }
public void SendData(byte[] data, bool reliableChannel) { if (connected) { if (id == 32767) { try { file.Write(data, 0, data.Length); } catch (Exception e) { Debug.LogError(e.Message); } } else { byte error; if (data.Length > 1000) { Debug.LogError("NEARING DATA LIMIT of 1400- this can be increased!"); } byte channel = parent.unreliableChannelId; if (reliableChannel) { channel = parent.reliableSequencedChannelId; } NetworkTransport.Send(parent.hostId, recConnectionId, channel, data, data.Length, out error); NetworkError networkError = (NetworkError)error; if (networkError != NetworkError.Ok) { Debug.LogError(string.Format("Error: {0}, hostId: {1}, connectionId: {2}, channelId: {3}", networkError, parent.hostId, this.recConnectionId, channel)); } } } }
public static void SendNetworkWriter <TPeer>(NetworkWriter writer, IEnumerable <TPeer> peers) where TPeer : NetworkPeer { byte error; byte[] bufferData = writer.AsArray(); short bufferSize = writer.Position; foreach (TPeer peer in peers) { if (!peer.isConnected) { return; } NetworkTransport.Send(peer.hostId, peer.connectionId, 0, bufferData, bufferSize, out error); #if SHOW_SEND_ERRORS NetworkError nerror = (NetworkError)error; if (nerror != NetworkError.Ok) { Debug.LogError("Network error: " + nerror); } #endif } }
void ClientManager_ConnectingFailed(NetworkError error) { Assert.IsTrue(m_ClientNetworkManager.Connection.IsConnected == false); Assert.IsTrue(m_ClientNetworkManager.Connection.LastError == error); Debug.Log("ClientManager_ConnectingFailed " + error); }
private bool IsFatalError(NetworkError error) { switch (error) { case NetworkError.WrongHost: case NetworkError.WrongConnection: case NetworkError.WrongChannel: case NetworkError.NoResources: case NetworkError.VersionMismatch: case NetworkError.DNSFailure: case NetworkError.CRCMismatch: case NetworkError.BadMessage: case NetworkError.UsageError: return(true); case NetworkError.Timeout: // Timeout is not considered an error for the server. A client can timeout without killing the server. case NetworkError.Ok: case NetworkError.MessageToLong: case NetworkError.WrongOperation: return(false); default: Log.CreatePossibleBugException(string.Format("Dissonance UNet received unknown NetworkError: '{0}'", error), "7975E556-3821-4360-8C60-31E9C03C4C4F"); return(true); } }
public void Init(bool isServer) { byte error; host = hostText.text; port = Convert.ToInt32(portText.text.ToString()); this.isServer = isServer; NetworkTransport.Init(); config = new ConnectionConfig(); config.AddChannel(QosType.Reliable); if (isServer) { topology = new HostTopology(config, 10); hostId = NetworkTransport.AddHost(topology, port); Debug.Log("Server started on port" + port + " with id of " + hostId); } else { topology = new HostTopology(config, 1); hostId = NetworkTransport.AddHost(topology, 0); connectionId = NetworkTransport.Connect(hostId, host, port, 0, out error); NetworkError networkError = (NetworkError)error; if (networkError != NetworkError.Ok) { Debug.LogError(string.Format("Unable to connect to {0}:{1}, Error: {2}", host, port, networkError)); } else { Debug.Log(string.Format("Connected to {0}:{1} with hostId: {2}, connectionId: {3}, channelId: {4},", host, port, hostId, connectionId, channelId)); } } isInit = true; }
public void actuallySendData() { // count size: if (outgoingMessages.Count > 0 && OperationNetwork.connected) { int size = 0; for (int i = 0; i < outgoingMessages.Count; i++) { size += outgoingMessages[i].Length; } byte[] sendData = new byte[size]; size = 0; for (int i = 0; i < outgoingMessages.Count; i++) { Buffer.BlockCopy(outgoingMessages[i], 0, sendData, size, outgoingMessages[i].Length); size += outgoingMessages[i].Length; } dataOutRate += sendData.Length; byte error; if (sendData.Length > 600) { Debug.LogError("Nearing Buffer Limit on Client! Count: " + sendData.Length); } NetworkTransport.Send(hostId, connectionId, reliableSequencedChannelId, sendData, sendData.Length, out error); NetworkError networkError = (NetworkError)error; if (networkError != NetworkError.Ok) { Debug.LogError(string.Format("Error: {0}, hostId: {1}, connectionId: {2}, channelId: {3}", networkError, hostId, connectionId, reliableSequencedChannelId)); } } outgoingMessages.Clear(); }
public void OnDisconnect(int hostId, int connectionId, NetworkError error) { Destroy(connectionClient[connectionId].Gtext); connectionClient.Remove(connectionId); Debug.Log("OnDisconnect(hostId = " + hostId + ", connectionId = " + connectionId + ", error = " + error.ToString() + ")"); }
public bool SendMessage(int connectionId, NetworkWriter writer, int channel, out NetworkError Error) { byte error; byte[] buffer = writer.ToArray(); NetworkTransport.Send(SocketId, connectionId, channel, buffer, buffer.Length, out error); Error = (NetworkError)error; if (Error != NetworkError.Ok) { return true; } else { return false; } }
public Recv( int hid ) { // TODO: Make the buffer size configurable buffer = new byte[1024]; byte err; msg = NetworkTransport.ReceiveFromHost( hid, out conId, out chanId, buffer , 1024, out recvSize, out err ); error = (NetworkError)err; }
private void Listen() { byte[] buffer = new byte[packetSize]; NetworkEventType rEvent = NetworkEventType.DataEvent; while (rEvent != NetworkEventType.Nothing) { byte rError; rEvent = NetworkTransport.Receive(out recSocketId, out recConnectionId, out recChannelId, buffer, buffer.Length, out recievedSize, out rError); recError = (NetworkError)rError; switch (rEvent) { case NetworkEventType.Nothing: break; case NetworkEventType.ConnectEvent: bool unexpectedConnection = isClient && recConnectionId != attemptConnectionId; if (recSocketId == localSocketId && !unexpectedConnection && recError == NetworkError.Ok) { ConnectionData data = GetConnectionData(recConnectionId); if (isServer) { for (int i = 0; i < clientConnectionIds.Length; i++) { if (clientConnectionIds[i] < 0) { clientConnectionIds[i] = recSocketId; break; } } numConnections++; foreach (NetScript inst in NetScript.Instances) { inst.OnBackstabClientConnected(data); } } else if (isClient) { serverConnectionId = recConnectionId; foreach (NetScript inst in NetScript.Instances) { inst.OnBackstabConnectedToServer(data); } } else { Debug.LogError("Can't connect if neither server nor client."); } } else { Debug.Log(string.Format("recieved socket id: {0} expected socket id: {1}", recSocketId, localSocketId)); //Debug.Log(string.Format("recieved connection id: {0} expected connection id: {1}", recConnectionId, attemptConnectionId)); foreach (NetScript inst in NetScript.Instances) { inst.OnBackstabFailedToConnect(); } } break; case NetworkEventType.DataEvent: System.Object packet = Deserialize(buffer); if (packet is RpcData) { GetRpc(packet as RpcData); } break; case NetworkEventType.DisconnectEvent: numConnections--; if (isServer) { clientConnectionIds[recConnectionId] = -99; foreach (NetScript inst in NetScript.Instances) { inst.OnBackstabClientDisconnected(); } } else { foreach (NetScript inst in NetScript.Instances) { inst.OnBackstabDisconnectedFromServer(); } } break; case NetworkEventType.BroadcastEvent: string address; int recPort; byte error; NetworkTransport.GetBroadcastConnectionInfo(broadcastSocket, out address, out recPort, out error); if (error != (byte)NetworkError.Ok) Debug.Log("Recieved broadcast from bad connection."); NetworkTransport.GetBroadcastConnectionMessage(broadcastSocket, buffer, buffer.Length, out recievedSize, out error); string message = (string)Deserialize(buffer); TryAddBroadcaster(address, port, message); foreach (NetScript inst in NetScript.Instances) { inst.OnBackstabGotBroadcast(); } break; default: Debug.LogError("Unrecognized event type"); break; } } }
private void onSent(IAsyncResult ar) { int tx = -1; try { tx = clientSocket.EndSend(ar); } catch (SocketException se) { ErrorOccured = true; Error = NetworkError.TransmissionError; ErrorMessage = se.Message; if (NetworkErrorOccured != null) NetworkErrorOccured(); return; } if (tx < 0) { ErrorOccured = true; Error = NetworkError.TransmissionError; ErrorMessage = "Transmission recieve error, data recieved was zero bytes"; if (NetworkErrorOccured != null) NetworkErrorOccured(); return; } }
public bool SendMessage(int connectionId, NetworkWriter writer, out NetworkError Error) { return SendMessage(connectionId, writer, 0, out Error); }
private bool SendMessage(NetworkWriter writer, int channelId, out NetworkError error) { error = NetworkError.WrongConnection; if (!isConnected) { Debug.LogWarning("LLApiClient is not Connected"); return false; } byte errorByte; byte[] buffer = writer.ToArray(); NetworkTransport.Send(SocketId, ConnectionId, channelId, buffer, buffer.Length, out errorByte); error = (NetworkError)errorByte; if(error!= NetworkError.Ok) { Debug.LogError("LLApiClient Sock: " + SocketId + " ConId: " + ConnectionId + " Error Sending Message : " + error); return false; } return true; }
private void onConnectComplete(IAsyncResult ar) { try { clientSocket.EndConnect(ar); this.Connected = true; } catch (SocketException se) { ErrorOccured = true; Error = NetworkError.ConnectionError; ErrorMessage = se.Message; if (NetworkErrorOccured != null) NetworkErrorOccured(); return; } catch (Exception e) { ErrorOccured = true; Error = NetworkError.UnknownError; ErrorMessage = e.Message; if (NetworkErrorOccured != null) NetworkErrorOccured(); return; } try { clientSocket.BeginReceive(buffer, 0, 1024, SocketFlags.None, onRecieveCallback, null); } catch (SocketException se) { if (se.ErrorCode == 10054) { this.Connected = false; ErrorOccured = true; Error = NetworkError.ConnectionError; ErrorMessage = se.Message; if (NetworkErrorOccured != null) NetworkErrorOccured(); } } if (OnConnectComplete != null) OnConnectComplete(); }
private void onRecieve(IAsyncResult ar) { int rx = -1; try { rx = clientSocket.EndReceive(ar); } catch (SocketException se) { if (se.ErrorCode == 10054) { ErrorOccured = true; Error = NetworkError.Disconnect; ErrorMessage = se.Message; return; } } byte[] recieved = new byte[rx]; Array.Copy(buffer, recieved, rx); string message = Encoding.ASCII.GetString(recieved); clientSocket.BeginReceive(buffer, 0, 1024, SocketFlags.None, onRecieveCallback, null); if (message.StartsWith("#LOGIN")) { var success = (message.Split('|')[1] == "true" ? true : false); if (success) { var isAdmin = (message.Split('|')[2] == "true" ? true : false); Usable = true; if (LoginComplete != null) LoginComplete(true); } else if (LoginComplete != null) LoginComplete(false); } else if (DataReady != null) DataReady(message); this.connecting = false; }
private bool SendMessage(NetworkWriter writer, out NetworkError error) { return SendMessage(writer, 0, out error); }
public void WriteLine(string line) { if (Usable || line.StartsWith("#LOGIN")) { byte[] data = Encoding.ASCII.GetBytes(line); try { clientSocket.BeginSend(data, 0, data.Length, SocketFlags.None, onSentCallback, null); } catch (SocketException se) { if (se.ErrorCode == 10054) { ErrorOccured = true; Error = NetworkError.Disconnect; ErrorMessage = se.Message; return; } } } }