public BeginSend ( IList |
||
buffers | IList |
|
socketFlags | SocketFlags | |
callback | AsyncCallback | |
state | object | |
return | IAsyncResult |
public void SendMessageToServer(string argCommandString) { // create a Packet object from the passed data; this packet can be any object type because we use serialization! //Dim mPacket As New Dictionary(Of String, String) //mPacket.Add("CMD", argCommandString) //mPacket.Add("MSG", argMessageString) string mPacket = argCommandString; // serialize the Packet into a stream of bytes which is suitable for sending with the Socket System.Runtime.Serialization.Formatters.Binary.BinaryFormatter mSerializer = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); System.IO.MemoryStream mSerializerStream = new System.IO.MemoryStream(); mSerializer.Serialize(mSerializerStream, mPacket); // get the serialized Packet bytes byte[] mPacketBytes = mSerializerStream.GetBuffer(); // convert the size into a byte array byte[] mSizeBytes = BitConverter.GetBytes(mPacketBytes.Length + 4); // create the async state object which we can pass between async methods SocketGlobals.AsyncSendState mState = new SocketGlobals.AsyncSendState(cClientSocket); // resize the BytesToSend array to fit both the mSizeBytes and the mPacketBytes // ERROR: Not supported in C#: ReDimStatement Array.Resize(ref mState.BytesToSend, mPacketBytes.Length + mSizeBytes.Length); // copy the mSizeBytes and mPacketBytes to the BytesToSend array System.Buffer.BlockCopy(mSizeBytes, 0, mState.BytesToSend, 0, mSizeBytes.Length); System.Buffer.BlockCopy(mPacketBytes, 0, mState.BytesToSend, mSizeBytes.Length, mPacketBytes.Length); cClientSocket.BeginSend(mState.BytesToSend, mState.NextOffset(), mState.NextLength(), SocketFlags.None, new AsyncCallback(MessagePartSent), mState); }
IWaitableValue <int> IStreamable.Send(byte[] buffer, int offset, int buffer_length) { /*if (!Socket.Connected) * { * _SocketErrorEvent(SocketError.SocketError); * return (0).ToWaitableValue(); * }*/ SocketError error; var ar = Socket.BeginSend(buffer, offset, buffer_length, SocketFlags.None, out error, _EndReceiveEmpty, null); var safeList = new[] { SocketError.Success, SocketError.IOPending }; if (!safeList.Any(s => s == error)) { _SocketErrorEvent(error); } if (ar == null) { return((0).ToWaitableValue()); } return(System.Threading.Tasks.Task <int> .Factory.FromAsync(ar, _EndSend).ToWaitableValue()); }
private void OnConnect(IAsyncResult ar) { try { clientSocket.EndConnect(ar); // here we are connected, so we send login request! byte[] bytesMsg; Message loginMsg = new Message(Command.Login, txtName.Text); bytesMsg = loginMsg.toByte(); clientSocket.BeginSend(bytesMsg, 0, bytesMsg.Length, SocketFlags.None, new AsyncCallback(OnSend), null); clientSocket.BeginReceive(byteData, 0, byteData.Length, SocketFlags.None, new AsyncCallback(OnReceive), null); } catch (Exception ex) { log("Something went wrong during establishing connection:"); log(ex.Message); btnConnect.Sensitive = true; btnDisconnect.Sensitive = false; btnMsg.Sensitive = false; } }
public void Send(string message) { if (handshaked) { Frame f = new Frame(message); byte[] b = draft.CreateClientFrameBytes(f); socket.BeginSend(b, 0, b.Length, SocketFlags.None, null, socket); } }
public void sendPackage(byte[] _data, Socket socket) { // DataPackage _data = new DataPackage("First package", 9999, true); // DroidMessage _data = new DroidMessage("Hello socket server"); try { if (isOnline == true) { byte[] data = _data; //_clientSocket.Send(buffer); // socket.Send(_data); socket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), socket); byte[] _buf = _buffersList.SingleOrDefault(k => k.Key == socket).Value; // socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), socket); socket.BeginReceive(_buf, 0, _buf.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), socket); } } catch (Exception ex) { if (OnServerError != null) { OnServerError(null, new NotyArgs(ex.Message)); } } }
public void SendMessage(Socket client, string message) { byte[] byteMessage = Encoding.ASCII.GetBytes(message); client.BeginSend(byteMessage, 0, byteMessage.Length, SocketFlags.None, new AsyncCallback(SendCallBack), client); sendDone.WaitOne(); sendDone.Reset(); }
/// <summary> /// 异步发送器 /// </summary> /// <param name="datagram">报文</param> /// <returns>返回是否成功</returns> public virtual bool Send(string datagram) { //如果没有连接无法发送报文 if (!IsConnection) { CutConnection("服务器未连接"); return(false); } try { //加上后缀 byte[] data = encod.ToString(datagram + this.Suffix); IAsyncResult iar = sock.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendDataEnd), sock); return(true); } catch (SocketException ex) { //服务器断开 CutConnection(ex.Message); } catch (ObjectDisposedException ex) { //服务器断开 CutConnection(ex.Message); } catch (Exception ex) { //服务器断开 CutConnection(ex.Message); } return(false); }
private async Task<String> httpRequest(Byte method, String headerAndBodyRaw, String link) { Socket youtubeSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Byte[] requbytes = new Byte[8192]; Int32 recvd = -1; String request = ""; String headerAndBody = ((method == 1) ? "GET /" : "POST /") + link + headerAndBodyRaw.Substring(headerAndBodyRaw.IndexOf("HTTP/1.1") - 1); try { await Task.Factory.FromAsync(youtubeSock.BeginConnect, youtubeSock.EndConnect, "www.youtube.com", 80, null); if (youtubeSock.Connected) { var buffer = Encoding.ASCII.GetBytes(headerAndBodyRaw); int bytessent = await Task.Factory.FromAsync<int>(youtubeSock.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, null, youtubeSock), youtubeSock.EndSend); if (await waitForDataToBecomeAvailable(2000, youtubeSock)) { recvd = youtubeSock.Receive(requbytes); request = Encoding.ASCII.GetString(requbytes).Substring(0, recvd); } youtubeSock.Dispose(); } return request; } catch (Exception err) { LogError("\nhttpRequest() - Error: " + err.Message + "\n\n" + err.StackTrace + "\n" + headerAndBodyRaw); } return ""; }
/// <summary> /// 异步发送信息 /// </summary> public void Send(int cmd, byte[] dataMsg) { if (_connectState == NetworkClientState.Closed) { Debug.LogError(cmd + "send error,connectState Closed"); return; } try { _msgCounter++; Debug.Log("<color=#00CA66FF>Send:" + cmd + "</color>"); ByteArray ba = new ByteArray(); if (dataMsg != null) { ba.Write(dataMsg.Length + 8); ba.Write(cmd); ba.Write(_msgCounter); ba.Write(dataMsg); } else { ba.Write(8); ba.Write(cmd); ba.Write(_msgCounter); } byte[] data = ba.GetByteArray(); ba.Destroy(); _socket.BeginSend(data, 0, data.Length, 0, DoSend, _socket); } catch (SocketException ex) { DoSendError(ex); } }
private static IEnumerator<IAsyncCall> Echo(Socket client) { byte[] buffer = new byte[1024]; AsyncCall<int> call = new AsyncCall<int>(); while (true) { yield return call .WaitOn(cb => client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, cb, null)) & client.EndReceive; int bytes = call.Result; if (bytes > 0) { Console.WriteLine("read {0} bytes from {1}", bytes, client.RemoteEndPoint); yield return call .WaitOn(cb => client.BeginSend(buffer, 0, bytes, SocketFlags.None, cb, null)) & client.EndReceive; Console.WriteLine("sent {0} bytes to {1}", bytes, client.RemoteEndPoint); } else { break; } } Console.WriteLine("closing client socket {0}", client.RemoteEndPoint); client.Close(); }
static void Main(string[] args) { var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); socket.Connect("localhost", 4530); //实现接受消息的方法 var buffer = new byte[1024];//设置一个缓冲区,用来保存数据 //socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback((ar) => //{ // var length = socket.EndReceive(ar); // var message = Encoding.Unicode.GetString(buffer, 0, length); // //显示读出来的消息 // Console.WriteLine(message); //}), null); Console.WriteLine("Client connec to the server"); socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveMessage), socket); //接受用户输入,将消息发送给服务器端 while (true) { var message = "message from client: " + Console.ReadLine(); var outputBuffer = Encoding.Unicode.GetBytes(message); socket.BeginSend(outputBuffer, 0, outputBuffer.Length, SocketFlags.None, null, null); } Console.Read(); }
public void BeginSend(Socket objSocket, byte[] data) { if (objSocket != null && objSocket.Connected) { objSocket.BeginSend(data, 0, data.Length, SocketFlags.None, this.SendAsynCallBack, objSocket); } }
public void SendAsync(byte[] Data, Action Callback = null) { var DataCopy = new byte[Data.Length]; Array.Copy(Data, DataCopy, Data.Length); var BuffersCopy = new List <ArraySegment <byte> >() { new ArraySegment <byte>(DataCopy) }; AsyncQueue.Add(() => { try { NativeSocket.BeginSend(BuffersCopy, SocketFlags.None, (IAsyncResult) => { SocketError SocketError; NativeSocket.EndSend(IAsyncResult, out SocketError); Core.EnqueueTask(() => { if (Callback != null) { Callback(); } AsyncQueue.Next(); }); }, null); } catch (SocketException SocketException) { SocketExceptionThrown(SocketException); } }); }
private static void BeginSend(Socket socket, byte [] buffer, State state) { if (socket == null) throw new ArgumentNullException("socket"); if (buffer == null) throw new ArgumentNullException("buffer"); if (socket.Connected) socket.BeginSend(buffer, 0, buffer.Length, 0, new AsyncCallback(SendCallback), state); }
public static void Send(Socket handler, String data, Boolean IsOver) { byte[] byteData = Encoding.UTF8.GetBytes(data); StateObject state = new StateObject(); state.workSocket = handler; state.IsOver = IsOver; handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), state); }
private void OnReceiveData(Socket socket) { string strLogin = "******"; socket = this.socket; byte[] data = Encoding.ASCII.GetBytes(strLogin); socket.BeginSend(data, 0, data.Length, SocketFlags.None, sendCallback, socket); }
public void WriteTo(Socket socket) { var messageDataLengthBytes = BitConverter.GetBytes(messageData.Length); var bytes = new byte[messageDataLengthBytes.Length + messageData.Length]; Buffer.BlockCopy(messageDataLengthBytes, 0, bytes, 0, messageDataLengthBytes.Length); Buffer.BlockCopy(messageData, 0, bytes, messageDataLengthBytes.Length, messageData.Length); socket.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, OnWrite, new State(socket)); }
private void Send(System.Net.Sockets.Socket client, String data) { // Convert the string data to byte data using ASCII encoding. byte[] byteData = Encoding.ASCII.GetBytes(data); // Begin sending the data to the remote device. client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client); }
public void Send(System.Net.Sockets.Socket handler, String data) { // Convert the string data to byte data using ASCII encoding. byte[] byteData = Encoding.ASCII.GetBytes(data); // Begin sending the data to the remote device. handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler); }
/** * Begins asynchronous writing. * * @param strData * The data to send. */ public void BeginWrite(string strData) { byte[] arrData = System.Text.Encoding.ASCII.GetBytes(strData + "\0"); try { penguinSocks.BeginSend(arrData, 0, arrData.Length, Sockets.SocketFlags.None, SendCallback, penguinSocks); }catch (System.Exception writeEx) { Out.Logger.WriteOutput("Could not send to socket: " + writeEx.Message, Out.Logger.LogLevel.Error); disconnectCall(); } }
public void SendMessage(Socket targetSocket, string messageContent, Action<string> messageSentCallBack) { byte[] message = BuildMessage(messageContent, Encoding.ASCII); if(message.Length>0) { var context = new SendContext() { TargetSocket = targetSocket, MessageContent = messageContent, MessageSentCallback = messageSentCallBack }; targetSocket.BeginSend(message, 0, message.Length, 0, new AsyncCallback(this.SendCallback), context); } }
public void send_packet(byte[] packet_data, int send_size,Socket socket) { try { socket.BeginSend(packet_data, 0, send_size, SocketFlags.None, new AsyncCallback(packet_send), socket_); } catch (SocketException se) { MessageBox.Show(se.Message); } }
private IEnumerator<IAsyncCall> SendReceive(string host, int port) { AsyncCall<IPHostEntry> call = new AsyncCall<IPHostEntry>(); yield return call .WaitOn(cb => Dns.BeginGetHostEntry(host, cb, null)) & Dns.EndGetHostEntry; if (!call.Succeeded) { Console.WriteLine(call.Exception.Message); yield break; } IPAddress addr = call.Result.AddressList[0]; Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); AsyncCall call2 = new AsyncCall(); yield return call2 .WaitOn(cb => socket.BeginConnect(new IPEndPoint(addr, port), cb, null)) & socket.EndConnect; if (!call2.Succeeded) { Console.WriteLine(call2.Exception.Message); yield break; } byte[] sendBuffer = System.Text.Encoding.ASCII.GetBytes("hello world"); byte[] receiveBuffer = new byte[1024]; AsyncCall<int> call3 = new AsyncCall<int>(); for (int i = 0; i < 128; ++i) { yield return call3 .WaitOn(cb => socket.BeginSend( sendBuffer, 0, sendBuffer.Length, SocketFlags.None, cb, null)) & socket.EndSend; int bytesSent = call3.Result; Console.WriteLine("{0} sent {1} bytes", socket.LocalEndPoint, bytesSent); if (bytesSent > 0) { yield return call3 .WaitOn(cb => socket.BeginReceive( receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None, cb, null)) & socket.EndReceive; Console.WriteLine("{0} read {1} bytes", socket.LocalEndPoint, call3.Result); } } Console.WriteLine("closing socket {0}", socket.LocalEndPoint); socket.Close(); }
private IAsyncResult _Send(byte[] buffer, int offset, int buffer_length, AsyncCallback handler, object obj) { SocketError error; var ar = Socket.BeginSend(buffer, offset, buffer_length, SocketFlags.None, out error, handler, obj); var safeList = new[] { SocketError.Success, SocketError.IOPending }; if (!safeList.Any(s => s == error)) { _SocketErrorEvent(error); } return(ar); }
/// <summary> /// 输出错误状态 /// </summary> /// <param name="state">错误状态</param> internal void ResponseError(ResponseState state) { if (DomainServer != null) { Response response = DomainServer.GetErrorResponseData(state, Header.IsGZip); if (response != null) { if (state != ResponseState.NotFound404 || Header.Method != MethodType.GET) { Header.Flag &= HeaderFlag.All ^ HeaderFlag.IsKeepAlive; } if (responseHeader(ref response)) return; } } byte[] data = errorResponseDatas[(int)state]; System.Net.Sockets.Socket socket = Socket; if (data != null && socket != null) { try { SendType = state == ResponseState.NotFound404 && Header.Method == MethodType.GET ? SendType.Next : SendType.Close; Data.Set(data, 0, data.Length); Timeout = Config.GetTimeout(Data.Length); #if DOTNET2 SocketError socketError; IAsyncResult async = socket.BeginSend(data, 0, Data.Length, SocketFlags.None, out socketError, onSendAsyncCallback, socket); if (socketError == SocketError.Success) { if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket); return; } #else sendAsyncLock.EnterSleepFlag(); sendAsyncEventArgs.SetBuffer(data, 0, Data.Length); if (socket.SendAsync(sendAsyncEventArgs)) { sendAsyncLock.SleepFlag = 0; Http.Header.ReceiveTimeout.Push(this, socket); sendAsyncLock.Exit(); return; } sendAsyncLock.ExitSleepFlag(); if (onSend()) return; #endif } catch (Exception error) { Server.RegisterServer.TcpServer.Log.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer); } } HeaderError(); }
///// <summary> ///// 获取请求表单数据[TRY+1] ///// </summary> ///// <param name="identity">HTTP操作标识</param> ///// <param name="page">WEB 页面</param> ///// <param name="type">获取请求表单数据回调类型</param> ///// <returns>是否匹配会话标识</returns> //internal override bool GetForm(long identity, AutoCSer.WebView.Page page, GetFormType type) //{ // if (Interlocked.CompareExchange(ref this.Identity, identity + 1, identity) == identity) // { // GetFormPage = page; // GetFormType = type; // tryGetForm(); // return true; // } // return false; //} /// <summary> /// 获取请求表单数据 /// </summary> /// <param name="page">WEB 页面</param> /// <param name="type">获取请求表单数据回调类型</param> internal override void GetForm(AutoCSer.WebView.Page page, GetFormType type) { ++this.Identity; GetFormPage = page; GetFormType = type; Flag |= SocketFlag.GetForm | SocketFlag.IsLoadForm; try { if (Header.Is100Continue == 0) { if (getForm()) return; } else { System.Net.Sockets.Socket socket = Socket; if (socket != null) { SendType = SendType.GetForm; Data.Set(continue100, 0, continue100.Length); Timeout = Config.GetTimeout(Data.Length); #if DOTNET2 SocketError socketError; IAsyncResult async = socket.BeginSend(continue100, 0, Data.Length, SocketFlags.None, out socketError, onSendAsyncCallback, socket); if (socketError == SocketError.Success) { if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket); return; } #else sendAsyncLock.EnterSleepFlag(); sendAsyncEventArgs.SetBuffer(continue100, 0, Data.Length); if (socket.SendAsync(sendAsyncEventArgs)) { sendAsyncLock.SleepFlag = 0; Http.Header.ReceiveTimeout.Push(this, socket); sendAsyncLock.Exit(); return; } sendAsyncLock.ExitSleepFlag(); if (sendAsyncEventArgs.SocketError == SocketError.Success && sendAsyncEventArgs.BytesTransferred == Data.Length && getForm()) return; #endif } } } catch (Exception error) { Server.RegisterServer.TcpServer.Log.Exception(error, null, LogLevel.Exception | LogLevel.AutoCSer); } HeaderError(); }
private bool SendAsync(byte[] buffer, int offset, int length) { bool closing = false; lock (this) { Socket socket = this.m_server; if (socket == null) { closing = true; } else { try { socket.BeginSend(buffer, offset, length, 0, out SocketError error, (ar) => { try { socket.EndSend(ar, out error); if (error != SocketError.Success) { closing = true; } } catch (Exception) { closing = true; } if (closing) { this.Close(); } }, null); if (error != SocketError.Success && error != SocketError.IOPending) { closing = true; } } catch (Exception) { closing = true; } } } if (closing) { this.Close(); } return(!closing); }
public static void SendFile(string path, string parentDirectory, Socket socketFd, ManualResetEvent handle) { //send File name var filePath = Path.Combine(parentDirectory, Path.GetFileName(path)); filePath = filePath.Replace('\\', '/'); var pathBytes = Encoding.ASCII.GetBytes(filePath); var pathSizeBytes = BitConverter.GetBytes(pathBytes.Length); try { socketFd.Send(pathSizeBytes, pathSizeBytes.Length, 0); socketFd.Send(pathBytes, pathBytes.Length, 0); } catch (Exception exc) { MessageBox.Show("Exception:\t\n" + exc.Message); var window = (ProjectZip)Application.OpenForms[0]; window.SetControls(true); } //send File size var file = File.ReadAllBytes(path); var fileSizeBytes = BitConverter.GetBytes(file.Length); try { socketFd.Send(fileSizeBytes, fileSizeBytes.Length, 0); } catch (Exception exc) { MessageBox.Show("Exception:\t\n" + exc.Message); var window = (ProjectZip)Application.OpenForms[0]; window.SetControls(true); } //send File var fas = new FileAndSize { SocketFd = socketFd, File = file, FileSize = file.Length, SizeRemaining = file.Length, Handle = handle }; socketFd.BeginSend(file, 0, (fas.SizeRemaining < FileAndSize.BUF_SIZE ? fas.SizeRemaining : FileAndSize.BUF_SIZE), 0, SendFileCallback, fas); }
public void SendMessage(Socket targetSocket, byte[] message, Action<SendResult> messageSentCallback) { var wrappedMessage = SocketUtils.BuildMessage(message); if (wrappedMessage.Length > 0) { targetSocket.BeginSend( wrappedMessage, 0, wrappedMessage.Length, SocketFlags.None, new AsyncCallback(SendCallback), new SendContext(targetSocket, wrappedMessage, messageSentCallback)); } }
void StartSend(SendingBuffer sendingBuffer) { //lock (mSendBufferQueue) //{ try { mSocket?.BeginSend(sendingBuffer.mBuffer, sendingBuffer.mHasSend, sendingBuffer.mPos1 - sendingBuffer.mHasSend, SocketFlags.None, SendCallback, sendingBuffer); } catch (Exception e) { Close(); Profiler.Log.WriteException(e); } //} }
public void Send(Socket socket, Data msg) { byte[] byteData = Data.Serialize(msg); if (byteData.Length == SocketState.BufferSize) Console.WriteLine("Won't be able to make difference between end of byte array and end of message."); else if (byteData.Length > SocketState.BufferSize) { Console.WriteLine("Message is too long. It is currently not supported."); } else { socket.BeginSend(byteData, 0, byteData.Length, SocketFlags.None, new AsyncCallback(this.SendCallback), socket); } }
public void Send(byte[] buffer) { try { if (ListenerSocker == null) { return; } ListenerSocker.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendCallBack), this); } catch (Exception ex) { Log.Log.GetLog().Error(this, "Send", ex); } }
/// <summary> /// Sends a byte array to the socket /// </summary> /// <param name="byteArray">data to be sent</param> /// <exception cref="Exception">Socket not bound or connected</exception> public void Write(byte[] byteArray) { if (!_socket.IsBound && !_socket.Connected) { throw new Exception("Unable to write. Socket is not bound or connected."); } try { _socket.BeginSend(byteArray, 0, byteArray.Length, SocketFlags.None, null, null); } catch (Exception e) { throw new Exception("Something went wrong writting on the socket.\n" + e.Message); } }
private void sendDrinks(System.Net.Sockets.Socket client) { // send drinks to client log("Constructing drink string:"); log(getDrinksForMessage()); Message drinks = new Message(Command.DescribeDrinks, getDrinksForMessage()); byte[] bytes = drinks.toByte(); client.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, new AsyncCallback(OnSend), client); }
public void send(byte[] data) { try { _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _clientSocket.NoDelay = true; IPAddress ipAddress = IPAddress.Parse(ip); //Server is listening on port 1000 IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 1000); //Connect to the server _clientSocket.Connect(ipEndPoint); _clientSocket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnSend), null); } catch { } }
public void Send(string Input) { try { byte[] Output = System.Text.ASCIIEncoding.ASCII.GetBytes(Input + "\0"); if (!ConnectionFired && IPacket.SocketUtils.IsConnected(Sock)) { Sock.BeginSend(Output, 0, Output.Length, 0, new System.AsyncCallback(SendCallback), Sockets.SocketFlags.None); } } catch (System.Exception Exception) { IServer.OnDisconnection(this); if (Program.Debug) { Utils.Log.Error("Client Socket [Send][" + Input + "] ", Exception.Message); } } }
Task IPeer.Send(byte[] buffer, int offset_i, int buffer_length) { var task = new Task() { Buffer = buffer, Offset = offset_i, Count = buffer_length }; try { _Socket.BeginSend(buffer, offset_i, buffer_length, SocketFlags.None, SendDone, state: task); } catch (Exception e) { _Enable = false; } return(task); }
/// <summary> /// Sends the command to the wifi controller, also has a 100 millisecond delay to ensure commands are not lost /// </summary> /// <param name="command">The command to control the lights</param> public async Task Send(byte[] command) { //TODO: USE ASYNC COMMANDS // ConnectAsync and SendAsync var sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); var serverAddr = IPAddress.Parse(Ip); var endPoint = new IPEndPoint(serverAddr, Port); sock.BeginConnect(endPoint, ConnectCallback, sock); ConnectDone.WaitOne(); sock.BeginSend(command, 0, command.Length, 0, SendCallback, sock); SendDone.WaitOne(); //sock.SendTo(command, endPoint); await Task.Delay(100); }
/// <summary> /// Sends the command to the wifi controller, also has a 100 millisecond delay to ensure commands are not lost /// </summary> /// <param name="command">The command to control the lights</param> public async Task Send(byte[] command) { var sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); var serverAddr = IPAddress.Parse(this.ip); var endPoint = new IPEndPoint(serverAddr, this.port); sock.BeginConnect(endPoint, ConnectCallback, sock); connectDone.WaitOne(); sock.BeginSend(command, 0, command.Length, 0, SendCallback, sock); sendDone.WaitOne(); //sock.SendTo(command, endPoint); System.Threading.Thread.Sleep(100); }
/// <summary> /// 发送消息 /// </summary> /// <param name="data">要传递的消息内容[字节数组]</param> public void OnSendMessage(byte[] data) { var stream = new MemoryStream(); switch (_encoderLengthFieldLength) { case 1: stream.Write(new[] { (byte)data.Length }, 0, 1); break; #if BIG_ENDIANESS case 2: stream.Write(EndianBitConverter.Big.GetBytes((short)data.Length), 0, 2); break; case 4: stream.Write(EndianBitConverter.Big.GetBytes(data.Length), 0, 4); break; case 8: stream.Write(EndianBitConverter.Big.GetBytes((long)data.Length), 0, 8); break; #else case 2: stream.Write(BitConverter.GetBytes((short)data.Length), 0, 2); break; case 4: stream.Write(BitConverter.GetBytes(data.Length), 0, 4); break; case 8: stream.Write(BitConverter.GetBytes((long)data.Length), 0, 8); break; #endif default: throw new Exception("unsupported decoderLengthFieldLength: " + _encoderLengthFieldLength + " (expected: 1, 2, 3, 4, or 8)"); } stream.Write(data, 0, data.Length); var all = stream.ToArray(); stream.Close(); _socket.BeginSend(all, 0, all.Length, SocketFlags.None, OnSendMessageComplete, all); }
public void Write(byte[] data, Action dataSentCallback = null) { if (data.Length < 1) { throw new InvalidOperationException("Cannot send 0 bytes"); } if (dataSentCallback != null) { this.onSentCallback = dataSentCallback; } Core.EventLoop.Instance.Push(() => { nativeSocket.BeginSend(data, 0, data.Length, Winsock.SocketFlags.None, _static_endSend, this); }); }
public static void EncryptPacket(Socket socket, ServerState state, int messageId, int unknown, byte[] plainText) { byte[] cipherText; if (messageId == 20100) { cipherText = plainText; } else if (messageId == 20104) { byte[] nonce = GenericHash.Hash(state.clientState.nonce.Concat(state.clientKey).Concat(state.serverKey.PublicKey).ToArray(), null, 24); plainText = state.nonce.Concat(state.sharedKey).Concat(plainText).ToArray(); cipherText = PublicKeyBox.Create(plainText, nonce, state.serverKey.PrivateKey, state.clientKey); } else { // nonce was already incremented in ClientCrypto.DecryptPacket cipherText = SecretBox.Create(plainText, state.nonce, state.sharedKey).Skip(16).ToArray(); } byte[] packet = BitConverter.GetBytes(messageId).Reverse().Skip(2).Concat(BitConverter.GetBytes(cipherText.Length).Reverse().Skip(1)).Concat(BitConverter.GetBytes(unknown).Reverse().Skip(2)).Concat(cipherText).ToArray(); socket.BeginSend(packet, 0, packet.Length, 0, new AsyncCallback(SendCallback), state); }
public void SendMessage(int type) { socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); socket.Connect(new IPEndPoint(ipAd, port)); ClientState state = new ClientState(); state.Client = socket; ASCIIEncoding asen = new ASCIIEncoding(); byte[] data = asen.GetBytes("[" + type + "," + DomainController.getInstance().myAccount.accountId + "]"); //add prefix to data state.DataToSend = new byte[data.Length + 4]; byte[] prefix = BitConverter.GetBytes(data.Length); //copy data size prefix Buffer.BlockCopy(prefix, 0, state.DataToSend, 0, prefix.Length); //copy the data Buffer.BlockCopy(data, 0, state.DataToSend, prefix.Length, data.Length); socket.BeginSend(state.DataToSend, 0, state.DataToSend.Length, SocketFlags.None, new AsyncCallback(ClientSendCallback), state); Thread.Sleep(50); }
protected virtual void Send(Socket socket, string message) { if (!(socket.Connected)) { // Tell anyone who's listening that we're not connected anymore if (this.RemoteDisconnect != null) { this.RemoteDisconnect(socket, EventArgs.Empty); } this.Log("Failed to send - socket disconnected"); return; } byte[] buffer = Encoding.Unicode.GetBytes(message); SocketError socketError; socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, out socketError, this.SendCallback, new SendWrapper(socket, message)); this.ProcessSocketError(socket, socketError); }
// TODO: make this stuff dynamic/correct! protected virtual void OnBtnMessageClicked(object sender, System.EventArgs e) { // message stuff string message = "Msg from server!"; byte[] data = System.Text.Encoding.ASCII.GetBytes(message); // get correct client! Gtk.TreeIter sel = new Gtk.TreeIter(); TreeModel tm; tvConnections.Selection.GetSelected(out tm, out sel); string address = (string)(tm.GetValue(sel, 0)); System.Net.Sockets.Socket client = (System.Net.Sockets.Socket)clients[0]; Message msg = new Message(Command.DescribeDrinks, "drink1/drink2/drink3"); byte[] bytes = msg.toByte(); client.BeginSend(bytes, 0, bytes.Length, SocketFlags.None, new AsyncCallback(OnSend), client); }
private void Send(Socket client, String data) { // Convert the string data to byte data using ASCII encoding. byte[] byteData = Encoding.ASCII.GetBytes(data); // Begin sending the data to the remote device. client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client); }
protected override int WriteSingleBuffer(ByteBuffer buffer) { socket.BeginSend(buffer.Bytes, buffer.Position, buffer.Length, SocketFlags.None, WriteCallback, null); return(buffer.Length); }
System.IAsyncResult Utils.Wrappers.Interfaces.ISocket.BeginSend(byte[] buffer, int offset, int size, SocketFlags socketFlags, System.AsyncCallback callback, object state) { return(InternalSocket.BeginSend(buffer, offset, size, socketFlags, callback, state)); }
/// <summary> /// 发送数据 /// </summary> /// <param name="handler"></param> /// <param name="data"></param> private static void Send(Socket handler, object data) { try { var sendData = data as DataEntity<ResponseData>; List<byte> byteData = new List<byte>(); if (sendData != null) { //byteData.AddRange(sendData.Header.ToByte()); //byteData.AddRange(sendData.Body.ToByte()); byteData.AddRange(sendData.Body.databuf.ToByte()); Console.WriteLine("--------------------应答响应数据【{0}】--------------------", Tool.GetDate()); Console.WriteLine("Send Data:{0}", sendData.ToString()); Console.WriteLine("-------------------------------------------------------------------------------"); _iLog.InfoFormat("-------------------------应答响应数据-------------------------"); _iLog.InfoFormat("Send Data:{0}", sendData.ToString()); _iLog.InfoFormat("--------------------------------------------------------------"); Console.WriteLine("发送数据:把byte转换为16进制:{0}", BitConverter.ToString(byteData.ToArray())); _iLog.InfoFormat("发送数据:把byte转换为16进制:{0}", BitConverter.ToString(byteData.ToArray())); } else { byteData.AddRange(Tool.GetEncoding().GetBytes(data.ToString())); } //开始发送 handler.BeginSend(byteData.ToArray(), 0, byteData.Count, 0, new AsyncCallback(SendCallback), handler); } catch (Exception ex) { Console.WriteLine(ex.Message); _iLog.Error(ex); } }
/// <summary> /// Send data to remote device. /// </summary> /// <param name="client"></param> /// <param name="byteData"></param> public void Send(System.Net.Sockets.Socket client, byte[] byteData) { client.BeginSend(byteData, 0, byteData.Length, SocketFlags.None, new AsyncCallback(SendCallback), client); }
void Send(Socket s,byte[] data) { s.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(send_Callback), s); }
//Send message to just a spacific client public void MsgToClient(string msg, Socket soc) { byte[] data = Encoding.ASCII.GetBytes(msg); soc.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallBack), soc); }
/// <summary> /// Send Data Async /// </summary> /// <param name="socket"></param> /// <param name="data"></param> public void SendAsync(Socket socket, byte[] data) { socket.BeginSend(data, 0, data.Length, 0, new AsyncCallback(SendCallback), socket); sendDone.WaitOne(); }
/// <summary> /// Send Data Async /// </summary> /// <param name="socket"></param> /// <param name="data">Message</param> public void SendAsync(Socket socket, String data) { byte[] byteData = Encoding.Unicode.GetBytes(data + EndOfMessage); socket.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), socket); sendDone.WaitOne(); }
public virtual void ReceiveCallback(IAsyncResult ar) { if (TotalSession >= 10000) { TotalSession = 0; } TotalSession++; System.Net.Sockets.Socket handler = ConnectSocket; var srb = ar.AsyncState as SocketReceiveBack; try { if (handler != null && !handler.Connected) //当近端主动Disconnect时会触发 { Sktconfig?.DisConnectCallback?.Invoke(this); LogMsg(handler.LocalEndPoint.ToString(), handler.RemoteEndPoint.ToString(), $"disconnect remote {handler.RemoteEndPoint}\r\n"); return; } //最大是设置的msgbuffer的长度,如果发送的数据超过了buffer的长度就分批次接收 //这里在客户端强制关闭也会进去这个回调,但是执行到EndReceive时会出错 SocketError se; var rEnd = handler?.EndReceive(ar, out se); if (rEnd > 0 && srb != null) { var receiveBytes = srb.Buffer.Take(rEnd.Value).ToArray(); if (LastSessionTime == DateTime.MinValue) {//websockethttp协议升级 #region 分析报文、文本 LastSessionTime = DateTime.Now; string receiveText = Encoder.GetString(receiveBytes); //确认客户端发送的是websocket握手协议包,解析出key if (receiveText.IndexOf("Sec-WebSocket-Version:", StringComparison.Ordinal) != -1) { SocketConnectType = SocketConnectType.WebSocket; string[] rawClientHandshakeLines = receiveText.Split(new [] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries); string secwebSocketKey = rawClientHandshakeLines.FirstOrDefault(e => e.Contains("Sec-WebSocket-Key:")); string acceptKey = SocketTool.ComputeWebSocketHandshakeSecurityHash09( secwebSocketKey?.Substring(secwebSocketKey.IndexOf(":", StringComparison.Ordinal) + 2)); var newHandshake = Encoder.GetBytes(SocketTool.ComputeNewHandshake(acceptKey)); //返回websocket握手包 handler.BeginSend(newHandshake, 0, newHandshake.Length, 0, SendCallback, null); handler.BeginReceive(srb.Buffer, 0, BufferSize, 0, ReceiveCallback, srb); LogMsg(handler.LocalEndPoint.ToString(), handler.RemoteEndPoint.ToString(), $"from remote {handler.RemoteEndPoint} webSocket first session receive data [{receiveText}]\r\n"); return; } #endregion } else if (SocketConnectType == SocketConnectType.WebSocket) {//websocket解析明文内容 receiveBytes = new DataFrame(receiveBytes).Content; } #region 解析每一个数据包 //LogMsg(handler.LocalEndPoint.ToString(), handler.RemoteEndPoint.ToString(), $"current session from remote {handler.RemoteEndPoint} receive data [{ BitConverter.ToString(receiveBytes)}]\r\n"); var bytepackage = GetPackage(receiveBytes); int queeCount = bytepackage.Count; handler.BeginReceive(srb.Buffer, 0, BufferSize, 0, ReceiveCallback, srb); for (int i = 0; i < queeCount; i++) { //下面是正常业务逻辑处理 var bytemsg = bytepackage.Dequeue(); if (bytemsg.Length == 0) { continue; } LogMsg(handler.LocalEndPoint.ToString(), handler.RemoteEndPoint.ToString(), $"from {handler.RemoteEndPoint} receive [{ BitConverter.ToString(bytemsg)}]\r\n"); if (srb.MsgRecevieCallBack != null) { srb.MsgRecevieCallBack(bytemsg, this); } else { Sktconfig?.ReceiveCallback?.Invoke(bytemsg, this); } //else //如果回调是空就原样返回,正常收发可达5000次/s //{ // Send(bytemsg); //} } #endregion } else //远端主动Disconnect时会到达这里 { if (handler != null) { Sktconfig?.DisConnectCallback?.Invoke(this); LogMsg(handler.LocalEndPoint.ToString(), handler.RemoteEndPoint.ToString(), $"remote {handler.RemoteEndPoint} has close\r\n"); } } LastSessionTime = DateTime.Now; } catch (SocketException sktex) { SocketException(handler, sktex); } catch (Exception ex) { Exception(ex); } }
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback callback, Object state) { #if DEBUG using (GlobalLog.SetThreadKind(ThreadKinds.User | ThreadKinds.Async)) { #endif bool canWrite = CanWrite; // Prevent race with Dispose. if (m_CleanedUp) { throw new ObjectDisposedException(this.GetType().FullName); } if (!canWrite) { throw new InvalidOperationException(SR.GetString(SR.net_readonlystream)); } // // parameter validation // if (buffer == null) { throw new ArgumentNullException("buffer"); } if (offset < 0 || offset > buffer.Length) { throw new ArgumentOutOfRangeException("offset"); } if (size < 0 || size > buffer.Length - offset) { throw new ArgumentOutOfRangeException("size"); } Socket chkStreamSocket = m_StreamSocket; if (chkStreamSocket == null) { throw new IOException(SR.GetString(SR.net_io_writefailure, SR.GetString(SR.net_io_connectionclosed))); } try { // // call BeginSend on the Socket. // IAsyncResult asyncResult = chkStreamSocket.BeginSend( buffer, offset, size, SocketFlags.None, callback, state); return(asyncResult); } catch (Exception exception) { if (exception is ThreadAbortException || exception is StackOverflowException || exception is OutOfMemoryException) { throw; } // // some sort of error occured on the socket call, // set the SocketException as InnerException and throw // throw new IOException(SR.GetString(SR.net_io_writefailure, exception.Message), exception); } #if DEBUG } #endif }
/// <summary> /// 数据发送完成后的处理 /// </summary> /// <returns></returns> private bool onSend() #endif { #if DOTNET2 System.Net.Sockets.Socket socket = (System.Net.Sockets.Socket)async.AsyncState; if (socket == Socket) { SocketError socketError; int count = socket.EndSend(async, out socketError); if (socketError == SocketError.Success) { #else START: if (sendAsyncEventArgs.SocketError == SocketError.Success) { int count = sendAsyncEventArgs.BytesTransferred; System.Net.Sockets.Socket socket; #endif Data.MoveStart(count); if (Data.Length == 0) { SendSizeLessCount = 0; //isShutdown = true; switch (SendType) { case SendType.Next: if (receiveNext()) return true; break; case SendType.Body: switch (HttpResponse.Type) { case ResponseType.ByteArray: Data.Array = HttpResponse.Body.Array; Data.SetFull(); goto SENDDATA; case ResponseType.SubByteArray: case ResponseType.SubBuffer: Data = HttpResponse.Body; SENDDATA: #if DOTNET2 if (socket != Socket) return false; #else if ((socket = Socket) == null) return false; #endif SendType = SendType.Next; Timeout = Config.GetTimeout(Data.Length); #if DOTNET2 async = socket.BeginSend(Data.Array, Data.Start, Data.Length, SocketFlags.None, out socketError, onSendAsyncCallback, socket); if (socketError == SocketError.Success) { if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket); return true; } break; #else sendAsyncLock.EnterSleepFlag(); sendAsyncEventArgs.SetBuffer(Data.Array, Data.Start, Data.Length); if (socket.SendAsync(sendAsyncEventArgs)) { sendAsyncLock.SleepFlag = 0; Http.Header.ReceiveTimeout.Push(this, socket); sendAsyncLock.Exit(); return true; } sendAsyncLock.ExitSleepFlag(); goto START; #endif case ResponseType.File: SendFileStream = new FileStream(HttpResponse.BodyFile.FullName, FileMode.Open, FileAccess.Read, FileShare.Read, Http.Header.BufferPool.Size, FileOptions.SequentialScan); if (HttpResponse.State == ResponseState.PartialContent206) SendFileStream.Seek(Header.RangeStart, SeekOrigin.Begin); SendType = SendType.File; Buffer.ToSubByteArray(ref Data); Timeout = Config.GetTimeout(ResponseSize); goto SENDFILE; } break; case SendType.File: SENDFILE: #if DOTNET2 if (socket != Socket) return false; #else if ((socket = Socket) == null) return false; #endif Data.Set(Buffer.StartIndex, (int)Math.Min(ResponseSize, Buffer.Length)); if (SendFileStream.Read(Data.Array, Data.Start, Data.Length) == Data.Length) { if ((ResponseSize -= Data.Length) == 0) SendType = SendType.Next; #if DOTNET2 async = socket.BeginSend(Data.Array, Data.Start, Data.Length, SocketFlags.None, out socketError, onSendAsyncCallback, socket); if (socketError == SocketError.Success) { if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket); return true; } #else sendAsyncLock.EnterSleepFlag(); sendAsyncEventArgs.SetBuffer(Data.Start, Data.Length); if (socket.SendAsync(sendAsyncEventArgs)) { sendAsyncLock.SleepFlag = 0; Http.Header.ReceiveTimeout.Push(this, socket); sendAsyncLock.Exit(); return true; } sendAsyncLock.ExitSleepFlag(); goto START; #endif } break; case SendType.GetForm: if (getForm()) return true; break; } } else if ((count >= TcpServer.Server.MinSocketSize || (count > 0 && SendSizeLessCount++ == 0)) && AutoCSer.Threading.SecondTimer.Now <= Timeout) { #if DOTNET2 if (socket == Socket) { async = socket.BeginSend(Data.Array, Data.Start, Data.Length, SocketFlags.None, out socketError, onSendAsyncCallback, socket); if (socketError == SocketError.Success) { if (!async.CompletedSynchronously) Http.Header.ReceiveTimeout.Push(this, socket); return true; } } #else if ((socket = Socket) != null) { sendAsyncLock.EnterSleepFlag(); sendAsyncEventArgs.SetBuffer(Data.Start, Data.Length); if (socket.SendAsync(sendAsyncEventArgs)) { sendAsyncLock.SleepFlag = 0; Http.Header.ReceiveTimeout.Push(this, socket); sendAsyncLock.Exit(); return true; } sendAsyncLock.ExitSleepFlag(); goto START; } #endif } #if DOTNET2 } #endif } return false; }
protected override IAsyncResult Begin(System.Net.Sockets.Socket socket, ByteBuffer[] bufs, AsyncCallback callback, object state) { return(socket.BeginSend(ByteBuffersToList(bufs), System.Net.Sockets.SocketFlags.None, callback, state)); }
static void Main(string[] args) { Console.Write("Enter your name:"); string name = Console.ReadLine(); Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8080)); Console.WriteLine("Connected to server,enter $q to quit"); name = "{<" + name.Trim() +">}"; byte[] nameBuf = Encoding.UTF8.GetBytes(name); client.BeginSend(nameBuf, 0, nameBuf.Length, SocketFlags.None, null, null); client.BeginReceive(buf, 0, buf.Length, SocketFlags.None, new AsyncCallback(Receive), client); while (true) { string msg = Console.ReadLine(); if (msg == "$q") { client.Close(); break; } byte[] output = Encoding.UTF8.GetBytes(msg); client.BeginSend(output, 0, output.Length, SocketFlags.None, null, null); } Console.Write("Disconnected . Press any key to exit..."); Console.ReadKey(); }
public void BeginSendNotConnected () { Socket sock = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); byte[] send_bytes = new byte[] {10, 11, 12, 13}; try { sock.BeginSend (send_bytes, 0, send_bytes.Length, SocketFlags.None, BSCallback, sock); Assert.Fail ("BeginSendNotConnected #1"); } catch (SocketException ex) { Assert.AreEqual (10057, ex.ErrorCode, "BeginSendNotConnected #2"); } catch { Assert.Fail ("BeginSendNotConnected #3"); } finally { sock.Close (); } }