public static void Start() { AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper; listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); listener.Bind(new IPEndPoint(IPAddress.Any, PORT)); Console.WriteLine("Waiting for a connection..." + GetLocalIpAddress()); while (true) { EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); StateObject state = new StateObject(); state.WorkSocket = listener; listener.ReceiveFrom(state.Buffer, ref remoteEndPoint); var rawMessage = Encoding.UTF8.GetString(state.Buffer); var messages = rawMessage.Split(';'); if (messages.Length > 1) { var command = messages[0]; var deviceName = messages[1]; Console.WriteLine("Command is received from Device Name +"+deviceName+"+"); string[] portno = remoteEndPoint.ToString().Split(':'); Send(portno[1],remoteEndPoint); } } }
public bool Start() { if (_started) return true; _socket = SocketUtils.OpenSocketConnection("api.triggrapp.com", 9090); if (_socket == null) { _started = false; return false; } _started = true; StateObject state = new StateObject(); state.workSocket = _socket; _socket.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state); SendHandshake(); StartHeartbeat(); return true; }
public SyncSocClient(string _ipAddress, int port, int timeout) { try { IPAddress ipAddress = System.Net.IPAddress.Parse(_ipAddress); mPort = port; remoteEP = new IPEndPoint(ipAddress, mPort); mSender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); if (timeout > 0) { mSender.ReceiveTimeout = timeout; mSender.SendTimeout = timeout; } //mSender.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, timeout); // The socket will linger for 10 seconds after Socket.Close is called. LingerOption lingerOption = new LingerOption(true, 10); mSender.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption); stateObj = new StateObject(mSender); } catch (Exception e) { SetErrorMessage(e, string.Format("소켓생성Error ip[{0}]/port[{1}]/timeout[{2}]]",_ipAddress,port,timeout)); Logger.error(e.ToString()); } }
private bool Connect(StateObject stateObject) { Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse(hostIp), hostPort); stateObject.workSocket = client; int retry = retryTime; while (true) { try { // Connect to the remote endpoint. client.Connect(ipEndPoint); break; } catch (Exception be) { retry--; Logging.LogError(be.Message); Logging.LogError("Retry time: " + retry); } if (retry <= 0) { Logging.LogError("Connecntion Error."); return false; } } client.SendTimeout = timeout; client.ReceiveTimeout = timeout; return true; }
public Object start(TransferObject to) { Object resultObject = null; String calleeClass = to.getCalleeClass(); String calleeMethod = to.getCalleeMethod(); StateObject stateObject = new StateObject(); stateObject.transferObject = to; try { if (Connect(stateObject)) { Send(stateObject); resultObject = Receive(stateObject); } } catch (Exception e) { Logging.LogError("Callee Class and Method: [" + calleeClass + "." + calleeMethod + "]"); Logging.LogError(e.ToString()); } finally { Close(stateObject); } return resultObject; }
public Connection(Server server, Socket socket) { m_Server = server; m_Socket = socket; var state = new StateObject { Socket = m_Socket }; m_Socket.BeginReceive(state.Buffer, 0, StateObject.BufferSize, SocketFlags.None, ReceiveCallback, state); }
public string ReadMessage(Socket client) { StateObject state = new StateObject(); state.workSocket = client; client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state); readDone.WaitOne(); readDone.Reset(); return state.sb.ToString(); }
public void AcceptCallback(IAsyncResult ar) { // Get the socket that handles the client request. Socket listener = (Socket)ar.AsyncState; Socket handler = listener.EndAccept(ar); // Create the state object. StateObject state = new StateObject(); state.workSocket = handler; AskForReceive(handler, state); }
//get the done state of a partial docket. private static bool getPartialDocketState(BindingList<object> partialDocket) { bool state = true; for (int i = 1; i < partialDocket.Count; i++) { if (!((Order)partialDocket[i]).Done) { state = false; break; } } return state; }
IAsyncResult BeginConnect(AsyncCallback requestCallback, object userToken) { var stateObject = new StateObject() { AsyncState = userToken, Callback = requestCallback, IsCompleted = false }; this.ConnectAsync(stateObject); return stateObject; }
public void StartReceiving() { if (OnNotifyMulticastSocketListener == null) throw new ApplicationException("No socket listener has been specified at OnNotifyMulticastSocketListener."); // Create the state object. StateObject state = new StateObject(); state.WorkSocket = udpSocket; //get in waiting mode for data - always (this doesn't halt code execution) Recieve(state); }
// Method passed to ThreadStart. // // This is the thread's starting point. It starts the process on the server machine, creates three ``state objects'', which will // help us handle the redirections asynchronously. We associate the BeginRead methods of the standard output and error streams // with our call-back (LocalReadCallback), to start processing the output of the command. We also associate the BeginRead() method // the socket to our socket read call-back (ReadCallback), so we can process the data received through the socket. public void DoWork() { Process process = Process.Start(_processStartInfo); LocalStateObject outputLocalStateObject = new LocalStateObject(_socket, process, process.StandardOutput.BaseStream); process.StandardOutput.BaseStream.BeginRead(outputLocalStateObject.Buffer, 0, LocalStateObject.BUFFER_SIZE, new AsyncCallback(LocalReadCallback), outputLocalStateObject); LocalStateObject errorLocalStateObject = new LocalStateObject(_socket, process, process.StandardError.BaseStream); process.StandardError.BaseStream.BeginRead(errorLocalStateObject.Buffer, 0, LocalStateObject.BUFFER_SIZE, new AsyncCallback(LocalReadCallback), errorLocalStateObject); StateObject stateObject = new StateObject(_socket, process); _socket.BeginReceive(stateObject.Buffer, 0, StateObject.BUFFER_SIZE, 0, new AsyncCallback(ReadCallback), stateObject); process.WaitForExit(); _socket.Close(); }
public static void AcceptCallback(IAsyncResult ar) { allDone.Set(); Socket listener = (Socket)ar.AsyncState; Socket handler = listener.EndAccept(ar); StateObject state = new StateObject(); state.workSocket = handler; handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state); }
void ConnectAsync(StateObject stateObject) { var e = new SocketAsyncEventArgs(); e.UserToken = stateObject; e.RemoteEndPoint = _endpoint; e.Completed += OnConnectedAsync; try { this.Client.ConnectAsync(e); } catch (Exception ex) { Console.WriteLine(ex.Message + " >" + ex.StackTrace); } }
public void AcceptCallback(IAsyncResult ar) { allDone.Set(); Socket listener = (Socket)ar.AsyncState; Socket handler = listener.EndAccept(ar); StateObject state = new StateObject(); state.workSocket = handler; handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, ReadCallbackFileRecive, state); flag = 0; }
public static void AcceptCallback(IAsyncResult ar) { // Signal the main thread to continue. allDone.Set(); // Get the socket that handles the client request. Socket listener = (Socket)ar.AsyncState; Socket handler = listener.EndAccept(ar); // Create the state object. StateObject state = new StateObject(); state.workSocket = handler; handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state); }
public void AcceptCallback(IAsyncResult ar) { // Signal the main thread to continue. // Get the socket that handles the client request. Socket listener = (Socket)ar.AsyncState; Socket handler = listener.EndAccept(ar); connectedClients.Add(handler); // Create the state object. StateObject state = new StateObject(); state.workSocket = handler; handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(DealCallback), state); listener.BeginAccept(new AsyncCallback(AcceptCallback), listener); }
private static void Receive(Socket client) { try { // Create the state object. StateObject state = new StateObject(); state.workSocket = client; // Begin receiving the data from the remote device. client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state); } catch (Exception e) { Console.WriteLine(e.ToString()); } }
// This is the call back function, which will be invoked when a client is connected public void OnClientConnect(IAsyncResult asyn) { try { // Here we complete/end the BeginAccept() asynchronous call // by calling EndAccept() - which returns the reference to // a new Socket object Socket handler = m_mainSocket.EndAccept(asyn); // Let the worker Socket do the further processing for the // just connected client StateObject state = new StateObject(); state.socket = handler; state.id = m_workerSocket.Count; m_workerSocket.Add(state); try { handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state); } catch (SocketException se) { //MessageBox.Show(se.Message); } // Display this client connection as a status message on the GUI String str = String.Format("Client # {0} connected", m_workerSocket.Count - 1); // Since the main Socket is now free, it can go back and wait for // other clients who are attempting to connect m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null); } catch (ObjectDisposedException) { } catch (SocketException se) { } }
public string Receive(Socket client) { try { // Create the state object. StateObject state = new StateObject(); state.workSocket = client; // Begin receiving the data from the remote device. var wait = client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state); wait.AsyncWaitHandle.WaitOne(); return state.sb.ToString(); } catch (Exception e) { Console.WriteLine(e.ToString()); throw new Exception("Some error occured" + e.Message); } }
public static void AcceptCallback(IAsyncResult ar) { allDone.Set(); if (ServerStarted == false) return; // Get the socket that handles the client request. Socket listener = (Socket)ar.AsyncState; Socket handler = listener.EndAccept(ar); IPEndPoint remoteIpEndPoint = handler.RemoteEndPoint as IPEndPoint; Form1.lbStats.Invoke((MethodInvoker)(() => Form1.lbStats.Items.Add(string.Format("{0} (SERVER) Connection from {1}", DateTime.Now, remoteIpEndPoint.Address)))); Form1.lbStats.Invoke((MethodInvoker)(() => Form1.lbStats.TopIndex = Form1.lbStats.Items.Count - 1)); // Create the state object. StateObject state = new StateObject(); state.workSocket = handler; handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state); }
void AcceptCallback(IAsyncResult ar) { try { // Cast the user data back to a socket object Socket s = ar.AsyncState as Socket; // End the accept and get the resulting client socket Socket s2 = s.EndAccept(ar); // Keep the "Accept" process in motion s.BeginAccept(acceptCallback, s); // Create a state object for client (real apps may cache these) StateObject state = new StateObject(); state.workerSocket = s2; // Start an async receive state.workerSocket.BeginReceive(state.buffer, 0, state.buffer.Length, 0, receiveCallback, state); } catch(SocketException e) { Debug.WriteLine(e.Message); if(isLogging) TraceLog.myWriter.WriteLine( "SocketException:"+ e.Message+e.StackTrace,"AcceptCallback"); } return; // Return the thread to the pool } // Async receive method + matching delegate variable
public static void Start() { AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper; listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); listener.Bind(new IPEndPoint(IPAddress.Any, PORT)); Console.WriteLine("Waiting for a connection...{0}", GetLocalIpAddress()); while (true) { EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); StateObject state = new StateObject(); state.WorkSocket = listener; listener.ReceiveFrom(state.Buffer, ref remoteEndPoint); var rawMessage = Encoding.UTF8.GetString(state.Buffer); var messages = rawMessage.Split(';'); if (messages.Length > 1) { var command = messages[0]; var deviceName = messages[1]; Console.WriteLine("Command '{0}' is received from Device Name '{1}'", command, deviceName); switch (command) { case SocketCommands.CONNECT: state.DeviceName = deviceName; remoteEndpoints.Add(remoteEndPoint); Send(rawMessage); break; default: Send(rawMessage); break; } } } }
public void setErrorMessage(Exception e, string errMsg) { StateObject stateObj = new StateObject(e); stateObj.SocMessage = errMsg; setErrorMessage(e, stateObj); }
//initial receive function private void Recieve(StateObject state) { // Begin receiving the data from the remote device. Socket client = state.WorkSocket; client.BeginReceiveFrom(state.Buffer, 0, StateObject.BufferSize, 0, ref localEndPoint, new AsyncCallback(ReceiveCallback), state); }
public void setErrorMessage(Exception e, StateObject obj) { obj.SocErrorMessage = e.Message; obj.Status = SocHandlerStatus.ERROR; Logger.error(obj); OnSocStatusChangedOnError(new SocStatusEventArgs(obj)); }
public int Send(Socket soc, byte[] buffer) { int retry = 0; int recv = 0; StateObject stateObj = new StateObject(soc); while (true) { try { stateObj.Data = Encoding.UTF8.GetString(buffer, 8, buffer.Length - 8); stateObj.Status = SocHandlerStatus.SENDING; stateObj.SocMessage = string.Format("메시지전송 {0} Msg[{1}]", soc.RemoteEndPoint.ToString(), stateObj.Data); recv = soc.Send(buffer, SocketFlags.None); Logger.debug(stateObj); OnSocStatusChangedOnDebug(new SocStatusEventArgs(stateObj)); if (recv == buffer.Length) break; } catch (ArgumentNullException ane) { stateObj.SocMessage = string.Format("메시지전송에러:{0}", ane.ToString()); setErrorMessage(ane, stateObj); return SocCode.SOC_ERR_CODE; } catch (SocketException se) { stateObj.SocMessage = string.Format("메시지전송에러:{0}", se.ToString()); setErrorMessage(se, stateObj); return SocCode.SOC_ERR_CODE; } catch (Exception e) { stateObj.SocMessage = string.Format("메시지전송에러:{0}", e.ToString()); setErrorMessage(e, stateObj); return SocCode.SOC_ERR_CODE; } if (retry >= 3) { stateObj.SocMessage = String.Format("메시지전송에러:retry >= 3 " + Encoding.UTF8.GetString(buffer, 0, recv)); setErrorMessage(new Exception("메시지전송에러:retry >= 3"), stateObj); return SocCode.SOC_ERR_CODE; } retry++; } return recv; }
public int Send(IPEndPoint iep, string msg) { StateObject stateObj; lock(mClientTableLock) { if (mHtClientTable.ContainsKey(iep.ToString())) { stateObj = mHtClientTable[iep.ToString()]; } else { stateObj = new StateObject(); stateObj.SocMessage = String.Format("{0} Send 대상연결이 없음 ", iep.ToString()); OnSocStatusChanged(new SocStatusEventArgs(stateObj)); return SocCode.SOC_ERR_CODE; } } return (Send(stateObj.Soc, SocUtils.GetPrefixInfo(msg)) - 8); //TEXT[msg length].... 8자리 감안 }
public int SendMsg(StateObject socObj) { return Send(socObj.Soc, socObj.Data); }
public virtual void ProcessMsg(StateObject socObj) { //need implementing }