private void AcceptCallback(IAsyncResult result) { if (Listener == null) { return; } try { Socket socket = Listener.EndAccept(result); // Finish accepting the incoming connection. Client client = new Client(this, socket); // Add the new connection to the dictionary. lock (ClientLock) Clients[socket] = client; // add the connection to list. OnClientConnection(new ClientEventArgs(client)); // Raise the OnConnect event. client.BeginReceive(ReceiveCallback, client); // Begin receiving on the new connection connection. Listener.BeginAccept(AcceptCallback, null); // Continue receiving other incoming connection asynchronously. } catch (NullReferenceException) { } // we recive this after issuing server-shutdown, just ignore it. catch (Exception e) { SysCons.LogError("AcceptCallback: {0}", e); } }
private static void UnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs e) { if (e.IsTerminating) { SysCons.LogError("Terminating because of unhandled exception."); } else { SysCons.LogError("Caught unhandled exception."); } Console.ReadLine(); }
int load(string rdf_file, uint record_size) { byte padding; char[] record; int ret; uint data_size; BinaryReader f = new BinaryReader(File.Open(rdf_file, FileMode.Open)); if (f == null) { return(-1); } /* Read file header information then ignore it*/ f.ReadByte(); f.ReadInt32(); f.ReadByte(); record = new char[record_size - 1]; /* Wrote custom memset method to handle 0ing out records */ Helpers.Util.Memset(record, 0, record_size); /* This loops through the file reading a record into memory */ while (f.BaseStream.Position != f.BaseStream.Length) { int n = (int)record_size; ret = f.Read(record, 0, n); if (ret == 1) { // Havee to write the on_record function as an abstract in the base class. //if (on_record(record, (uint)ret) != 0) //{ return(-1); //} } else if (f.BaseStream.Position != f.BaseStream.Length) { SysCons.LogError("%s: error loading [%s]: read %d vs %d\n", System.Reflection.MethodBase.GetCurrentMethod().Name, rdf_file, record_size, ret); return(-1); } } record = null; f = null; return(0); }
public virtual bool Listen(string bindIP, int port) { // Check if the server has been disposed. if (_disposed) { throw new ObjectDisposedException(this.GetType().Name, "Server has been disposed."); } // Check if the server is already listening. if (IsListening) { throw new InvalidOperationException("Server is already listening."); } // Create new TCP socket and set socket options. Listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // Setup our options: // * NoDelay - don't use packet coalescing // * DontLinger - don't keep sockets around once they've been disconnected Listener.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true); Listener.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true); try { // Bind. Listener.Bind(new IPEndPoint(IPAddress.Parse(bindIP), port)); this.Port = port; } catch (SocketException) { SysCons.LogError(string.Format("{0} can't bind on {1}, server shutting down..", this.GetType().Name, bindIP)); this.Shutdown(); return(false); } // Start listening for incoming connections. Listener.Listen(10); IsListening = true; // Begin accepting any incoming connections asynchronously. Listener.BeginAccept(AcceptCallback, null); return(true); }
private void ReceiveCallback(IAsyncResult result) { Client client = result.AsyncState as Client; // Get the connection connection passed to the callback. if (client == null) { return; } try { int bytesRecv = client.EndReceive(result); // Finish receiving data from the socket. if (bytesRecv > 0) { OnDataReceived(new ClientDataEventArgs(client, client.RecvBuffer)); // Raise the DataReceived event. if (client.IsConnected) { client.BeginReceive(ReceiveCallback, client); // Begin receiving again on the socket, if it is connected. } else { RemoveClient(client, true); // else remove it from connection list. } } else { RemoveClient(client, true); // Connection was lost. } } catch (SocketException) { RemoveClient(client, true); // An error occured while receiving, connection has disconnected. } catch (Exception e) { SysCons.LogError("ReceiveCallback: {0}", e); } }
public virtual int Send(Client client, byte[] buffer, int start, int count, SocketFlags flags) { if (client == null) { throw new ArgumentNullException("client"); } if (buffer == null) { throw new ArgumentNullException("buffer"); } int totalBytesSent = 0; int bytesRemaining = buffer.Length; try { while (bytesRemaining > 0) // Ensure we send every byte. { int bytesSent = client.Socket.Send(buffer, totalBytesSent, bytesRemaining, flags); // Send the remaining data. if (bytesSent > 0) { OnDataSent(new ClientDataEventArgs(client, buffer)); // Raise the Data Sent event. } // Decrement bytes remaining and increment bytes sent. bytesRemaining -= bytesSent; totalBytesSent += bytesSent; } } catch (SocketException) { RemoveClient(client, true); // An error occured while sending, connection has disconnected. } catch (Exception e) { SysCons.LogError("Send: {0}", e); } return(totalBytesSent); }