public BeginSendTo ( byte buffer, int offset, int size, SocketFlags socketFlags, |
||
buffer | byte | |
offset | int | |
size | int | |
socketFlags | SocketFlags | |
remoteEP | ||
callback | AsyncCallback | |
state | object | |
Résultat | IAsyncResult |
private void btnOK_Click(object sender, EventArgs e) { strName = txtName.Text; try { //Using UDP sockets clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); //IP address of the server machine IPAddress ipAddress = IPAddress.Parse(txtServerIP.Text); //Server is listening on port 1000 IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 1000); epServer = (EndPoint)ipEndPoint; Data msgToSend = new Data (); msgToSend.cmdCommand = Command.Login; msgToSend.strMessage = null; msgToSend.strName = strName; byte[] byteData = msgToSend.ToByte(); //Login to the server clientSocket.BeginSendTo(byteData, 0, byteData.Length, SocketFlags.None, epServer, new AsyncCallback(OnSend), null); } catch (Exception ex) { MessageBox.Show(ex.Message, "SGSclient", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
internal void FirstMessage(Socket udp,EndPoint sep) { DataHandle Handle = new DataHandle(); string _mess = Generate._AppID + "," + Generate._licenceKey + "," + Generate.GetMacAddress() + "," + udp.LocalEndPoint.ToString(); byte[] data = Handle.HaSe(1000,_mess); udp.BeginSendTo(data, 0, data.Length, SocketFlags.None, sep, new AsyncCallback((async) => { }), udp); }
//metodo eseguito al click sul pulsante connetti private void btnConnect_Click(object sender, EventArgs e) { //vengono memorizzati il nome utente e //viene aggiornata la casella di testo _userName = txtUserName.Text.Trim(); _setText = SetText; //viene creato e riempito un pacchetto di richiesta di join alla chat Packet sendData = new Packet(); sendData.DataIdentifier = DataTypeIdentifier.Login; sendData.UserName = _userName; //viene creato un Socket UDP _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); //viene creato un oggetto contenente l'indirizzo IP e la porta del server IPAddress serverIP = IPAddress.Parse(txtServerAddress.Text); int serverPort = int.Parse(txtServerPort.Text); _epServer = new IPEndPoint(serverIP, serverPort); //il pacchetto creato viene convertito in un'array di byte _dataStream = sendData.ToByteArray(); //il pacchetto creato viene spedito al server _clientSocket.BeginSendTo(_dataStream, 0, _dataStream.Length, SocketFlags.None, _epServer, SendData, null); //tutti gli oggetti vengono sempre passati per referenza //il client si mette ora in ascolto dei messaggi provenienti dal server EndPoint ep = _epServer; _dataStream = new byte[Properties.Settings.Default.MAX_PACKET_LENGTH]; _clientSocket.BeginReceiveFrom(_dataStream, 0, _dataStream.Length, SocketFlags.None, ref ep, ReceiveData, null); }
/// <summary> /// Send message as MessageHandler to desired client /// </summary> /// <param name="message"></param> public void SendToClient(MessageHandler message, Socket serverSocket) { var buffer = Encoding.ASCII.GetBytes(message.message); //TODO: Check if client socket is connected if not stall message serverSocket.BeginSendTo(buffer, 0, buffer.Length, SocketFlags.None, new IPEndPoint(IPAddress.Loopback, 1025), new AsyncCallback(SendToClientCallBack), serverSocket); }
public IAsyncResult BeginSend(byte[] buffer, int offset, int length, IPEndPoint endPoint, AsyncCallback callback, object state) { MyAsyncResult result = new MyAsyncResult() { Callback = callback, State = state }; result.AsyncResult = _socket.BeginSendTo(buffer, offset, length, SocketFlags.None, endPoint, OnSocketCallback, result); return(result); }
public static async Task<bool> DiscoverAsync(object state = null) { Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); sock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1); IPEndPoint endpoint = new IPEndPoint(IPAddress.Broadcast, 1900); byte[] outBuf = Encoding.ASCII.GetBytes(BroadcastPacket); byte[] inBuf = new byte[4096]; int tries = MaxTries; while (--tries > 0) { try { TaskFactory factory = new TaskFactory(); sock.ReceiveTimeout = DiscoverTimeout; await factory.FromAsync(sock.BeginSendTo(outBuf, 0, outBuf.Length, 0, endpoint, null, null), end => { sock.EndSendTo(end); }).ConfigureAwait(false); var ar = sock.BeginReceive(inBuf, 0, inBuf.Length, 0, null, null); if (ar == null) throw new Exception("ar is null"); int length = await factory.FromAsync(ar, end => sock.EndReceive(end)).ConfigureAwait(false); string data = Encoding.ASCII.GetString(inBuf, 0, length).ToLowerInvariant(); var match = ResponseLocation.Match(data); if (match.Success && match.Groups["location"].Success) { System.Diagnostics.Debug.WriteLine("Found UPnP device at " + match.Groups["location"]); string controlUrl = GetServiceUrl(match.Groups["location"].Value); if (!string.IsNullOrEmpty(controlUrl)) { _controlUrl = controlUrl; System.Diagnostics.Debug.WriteLine("Found control URL at " + _controlUrl); return true; } } } catch (Exception ex) { // ignore timeout exceptions if (!(ex is SocketException && ((SocketException) ex).ErrorCode == 10060)) { System.Diagnostics.Debug.WriteLine(ex.ToString()); } } } return false; }
void Send() { while (Environment.TickCount < _iTime) { IPEndPoint ipEndPoint = new IPEndPoint(Utils.ResolveHost(this._strHost), this._iPort); Socket s = new Socket(AddressFamily.InterNetwork, this._strType == "Udp" ? SocketType.Dgram : SocketType.Stream, this._strType == "Udp" ? ProtocolType.Udp : ProtocolType.Tcp); int iPort = _iPort == 0 ? Utils.RandomInt(1, 65500) : _iPort; byte[] arr_bPacket = null; switch (this._strType) { case "Udpflood": arr_bPacket = Utils.GetBytes(Utils.RandomString(Utils.RandomInt(128, 512))); s.BeginSendTo(arr_bPacket, 0, arr_bPacket.Length, SocketFlags.None, (EndPoint)ipEndPoint, new AsyncCallback(SendToCallback), s); break; case "Httpflood": arr_bPacket = Utils.GetBytes(this.BuildPacket(false, -1)); s.Connect((EndPoint)ipEndPoint); s.Send(arr_bPacket); s.Close(); break; case "Condis": s.BeginConnect((EndPoint)ipEndPoint, new AsyncCallback(ConnectCallback), s); break; case "Slowpost": int iPacketSize = Utils.RandomInt(128,512); int iSent = 0; arr_bPacket = Utils.GetBytes(this.BuildPacket(true, iPacketSize)); s.Connect((EndPoint)ipEndPoint); s.Send(arr_bPacket); while (iSent < iPacketSize) { iSent += s.Send(Utils.GetBytes(Utils.RandomString(1))); Thread.Sleep(100); } s.Send(Utils.GetBytes("Connection: close")); s.Close(); break; default: break; } GC.Collect(); Thread.Sleep(10); } }
public void Arping( IPAddress ipToSearchFor ) { string ownMAC; string ownIP; getLocalMacAndIP( out ownIP, out ownMAC ); char[] aDelimiter = { '.' }; string[] aIPReso = ipToSearchFor.ToString().Split( aDelimiter, 4 ); string[] aIPAddr = ownIP.Split( aDelimiter, 4 ); byte[] oPacket = new byte[] { /*0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, Convert.ToByte("0x" + ownMAC.Substring(0,2), 16), Convert.ToByte("0x" + ownMAC.Substring(2,2), 16), Convert.ToByte("0x" + ownMAC.Substring(4,2), 16), Convert.ToByte("0x" + ownMAC.Substring(6,2), 16), Convert.ToByte("0x" + ownMAC.Substring(8,2), 16), Convert.ToByte("0x" + ownMAC.Substring(10,2), 16), 0x08, 0x06,*/ 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01, Convert.ToByte("0x" + ownMAC.Substring(0,2), 16), Convert.ToByte("0x" + ownMAC.Substring(2,2), 16), Convert.ToByte("0x" + ownMAC.Substring(4,2), 16), Convert.ToByte("0x" + ownMAC.Substring(6,2), 16), Convert.ToByte("0x" + ownMAC.Substring(8,2), 16), Convert.ToByte("0x" + ownMAC.Substring(10,2), 16), Convert.ToByte(aIPAddr[0], 10), Convert.ToByte(aIPAddr[1], 10), Convert.ToByte(aIPAddr[2], 10), Convert.ToByte(aIPAddr[3], 10), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, Convert.ToByte(aIPReso[0], 10), Convert.ToByte(aIPReso[1], 10), Convert.ToByte(aIPReso[2], 10), Convert.ToByte(aIPReso[3], 10)}; Socket arpSocket; arpSocket = new Socket( System.Net.Sockets.AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.Raw ); //arpSocket.SetSocketOption( SocketOptionLevel.IP, SocketOptionName.HeaderIncluded, true ); arpSocket.EnableBroadcast = true; EndPoint localEndPoint = new IPEndPoint( IPAddress.Any, 0 ); EndPoint remoteEndPoint = new IPEndPoint( ipToSearchFor, 0 ); arpSocket.Bind( localEndPoint ); arpSocket.BeginSendTo( oPacket,0,oPacket.Length,SocketFlags.None, remoteEndPoint, null, this); byte[] buffer = new byte[100]; arpSocket.BeginReceiveMessageFrom( buffer, 0, 100, SocketFlags.None, ref remoteEndPoint, null, this); }
private void _Run(object state) { ManualResetEvent mre = new ManualResetEvent(true); while (_Enable) { _Mre.WaitOne(); SocketMessage message; lock (_Messages) { if (_Messages.Count > 0) { message = _Messages.Dequeue(); } else { _Mre.Reset(); continue; } } int size = message.GetPackageSize(); mre.Reset(); try { m_Socket.BeginSendTo(message.Package, 0, size, SocketFlags.None, message.RemoteEndPoint, _Done, mre); } catch (Exception e) { } mre.WaitOne(); /*var * size = message.GetPackageSize(); * var count = 0; * while (count < size) * { * count += m_Socket.SendTo(message.Package, count, size - count, SocketFlags.None, message.RemoteEndPoint); * }*/ } }
void btnConnect_Click(object sender, RoutedEventArgs e) { try { string msgConn = tbName.Text + " connected"; clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); IPAddress serverIP = IPAddress.Parse(tbIp.Text); server = new IPEndPoint(serverIP, 30000); epServer = (EndPoint)server; byteData = Encoding.UTF8.GetBytes(msgConn); clientSocket.BeginSendTo(byteData, 0, byteData.Length > 1024 ? 1024 : byteData.Length, SocketFlags.None, epServer, new AsyncCallback(OnSend), null); bytes = new byte[1024]; clientSocket.BeginReceiveFrom(bytes, 0, 1024, SocketFlags.None, ref epServer, new AsyncCallback(ReceiveData), null); } catch (Exception ex) { MessageBox.Show("Connection Error: " + ex.Message); } }
public string TestSendUDPToService(string ipaddress,int port) { Socket socket = new Socket(SocketType.Dgram, ProtocolType.Udp); m_bufferManager = BufferManager.CreateBufferManager(100 * 1024, 1024); for(int i =0 ;i<=50;i++) { AsyncClientToken asyncClientToken = new AsyncClientToken(); //asyncClientToken.HandlerReturnData = handlerReturnData; asyncClientToken.Socket = socket; //asyncClientToken.MessageID = messageID; asyncClientToken.IP = ipaddress; asyncClientToken.Port = port; asyncClientToken.Buffer = m_bufferManager.TakeBuffer(1024); IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(asyncClientToken.IP), asyncClientToken.Port); int sendCount = Encoding.UTF8.GetBytes("TestSendUDPToService" + i.ToString(), 0, ("TestSendUDPToService" + i.ToString()).Length, asyncClientToken.Buffer, 0); CommonVariables.LogTool.Log(DateTime.Now.ToString(CommonFlag.F_DateTimeFormat) + " Send:" + asyncClientToken.IP + asyncClientToken.Port.ToString() + "TestSendUDPToService" + i.ToString()); socket.BeginSendTo(asyncClientToken.Buffer, 0, sendCount, SocketFlags.None, ipe, new AsyncCallback(SendCallback), asyncClientToken); } return null; }
private void event_ip() { strName = util.globals.local_name; ip = util.globals.popup_rep; util.globals.popup_rep = null; try { //Using UDP sockets clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); //IP address of the server machine IPAddress ipAddress = IPAddress.Parse(ip); //Server is listening on port 1000 IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 1000); epServer = (EndPoint)ipEndPoint; Client.Data msgToSend = new Client.Data (); msgToSend.cmdCommand = Client.Command.Login; msgToSend.strMessage = null; msgToSend.strName = strName; byte[] byteData = msgToSend.ToByte(); //Login to the server clientSocket.BeginSendTo(byteData, 0, byteData.Length, SocketFlags.None, epServer, new AsyncCallback(OnSend), null); } catch (Exception ex) { MessageBox.Show(ex.Message, "SGSclient", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
private void btnConnect_Click(object sender, EventArgs e) { /////////// Поиск ip клиента из DNS таблицы хоста IPHostEntry host = Dns.GetHostEntry(Dns.GetHostName()); string ip = ""; for (int i = 0; i < host.AddressList.Length; i++) { ip = host.AddressList[i].ToString(); string pattern = @"\d\d?\d?\.\d\d?\d?\.\d\d?\d?\.\d\d?\d?"; Regex regex = new Regex(pattern); Match match = regex.Match(ip); if (match.Success) { break; } } try { // Initialise a packet object to store the data to be sent Packet sendData = new Packet(); sendData.ChatMessage = null; sendData.ChatDataIdentifier = DataIdentifier.LogIn; // Initialise socket if (clientSocket != null) { try { clientSocket.Close(); } catch { } } this.clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); IPEndPoint ClientIPE; if (ip != "") ClientIPE = new IPEndPoint(IPAddress.Parse(ip), 8080); else { MessageBox.Show("Не удалось настроить ip адрес Клиента"); return; } clientSocket.Bind(ClientIPE); IPAddress serverIP; // Initialise server IP if (txtIP.Text.Trim() != "") serverIP = IPAddress.Parse(txtIP.Text.Trim()); else { MessageBox.Show("Введите ip адрес Сервера"); return; } // Initialise the IPEndPoint for the server and use port 30000 IPEndPoint server = new IPEndPoint(serverIP, 30000); // Initialise the EndPoint for the server epServer = (EndPoint)server; // Get packet as byte array byte[] data = sendData.GetDataStream(); // Send data to server clientSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, epServer, new AsyncCallback(this.SendData), null); // Initialise data stream this.dataStream = new byte[1024]; // Begin listening for broadcasts clientSocket.BeginReceiveFrom(this.dataStream, 0, this.dataStream.Length, SocketFlags.None, ref epServer, new AsyncCallback(this.ReceiveData), null); } catch (ObjectDisposedException) { MessageBox.Show("Не удалось подключиться к указанному серверу"); } catch (ArgumentException) { } catch (Exception ex) { try { clientSocket.Close(); } catch { } if (ex.Message == "Удаленный хост принудительно разорвал существующее подключение") MessageBox.Show("Не удалось подключиться к серверу", "UDP Client", MessageBoxButtons.OK, MessageBoxIcon.Error); else MessageBox.Show("Connection Error: " + ex.Message, "UDP Client", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
private void LoginForm_Load(object sender, EventArgs e) { CheckForIllegalCrossThreadCalls = false; try { //Server is listening on port 1000 foreach (IPAddress ip in Dns.GetHostAddresses(Dns.GetHostName())) if (ip.AddressFamily == AddressFamily.InterNetwork) IPHost = ip; IPEndPoint _localEndPoint = new IPEndPoint(IPHost, 0); IPEndPoint _ipEndPoint = new IPEndPoint(IPAddress.Broadcast, 11000); _findSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); _findSocket.Bind(_localEndPoint); _findSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1); //_findSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontRoute, 1); epServer = (EndPoint)_ipEndPoint; Data msgToSend = new Data(); msgToSend.cmdCommand = Command.ServerList; msgToSend.strMessage = null; msgToSend.strName = null; _byteDataReg = msgToSend.ToByte(); //Find the servers _findSocket.BeginSendTo(_byteDataReg, 0, _byteDataReg.Length, SocketFlags.None, epServer, new AsyncCallback(OnSendReg), null); _byteDataReg = new byte[1024]; //Start listening to the data asynchronously _findSocket.BeginReceiveFrom(_byteDataReg, 0, _byteDataReg.Length, SocketFlags.None, ref epServer, new AsyncCallback(OnReceiveReg), null); } catch (Exception ex) { MessageBox.Show(ex.Message, "SGSclient", MessageBoxButtons.OK, MessageBoxIcon.Error); } txtName.Text = "user" + (new Random(DateTime.Now.Millisecond).Next() % 89 + 10); }
void sendCommand(string _cmd) { Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); byte[] _byteData = Encoding.UTF8.GetBytes(_cmd); IPAddress ip = IPAddress.Parse(Program.GetLocalIP4()); IPEndPoint ipEndPoint = new IPEndPoint(ip, Program.outputPort); clientSocket.BeginSendTo(_byteData, 0, _byteData.Length, SocketFlags.None, ipEndPoint, getResponseData, clientSocket); }
/// <summary> /// Allows the game to perform any initialization it needs to before starting to run. /// This is where it can query for any required services and load any non-graphic /// related content. Calling base.Initialize will enumerate through any components /// and initialize them as well. /// </summary> protected override void Initialize() { // TODO: Add your initialization logic here strName = "nicktest"; ship ship1 = new ship(); ship1.shipx = 0; ship1.shipy = 0; ship1.shipObj = Content.Load<Texture2D>("test"); shipList.Add(ship1); ship ship2 = new ship(); ship2.shipx = 300; ship2.shipy = 300; ship2.shipObj = Content.Load<Texture2D>("test"); shipList.Add(ship2); //Using UDP sockets clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); IPAddress ipAddress = ipHostInfo.AddressList[0]; Console.WriteLine(ipAddress); //Server is listening on port 1000 IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 11000); epServer = (EndPoint)ipEndPoint; Data msgToSend = new Data(); msgToSend.cmdCommand = Command.Login; msgToSend.strMessage = null; msgToSend.strName = strName; byte[] byteData = msgToSend.ToByte(); //Login to the server clientSocket.BeginSendTo(byteData, 0, byteData.Length, SocketFlags.None, epServer, new AsyncCallback(OnSend), null); byteData = new byte[1024]; //Start listening to the data asynchronously clientSocket.BeginReceiveFrom(byteData, 0, byteData.Length, SocketFlags.None, ref epServer, new AsyncCallback(OnReceive),null); base.Initialize(); }
public static Task <int> SendToAsync(this Socket socket, ArraySegment <byte> buffer, SocketFlags socketFlags, EndPoint remoteEP) { return(Task.Factory.FromAsync((arg1, arg2, arg3, callback, state) => socket.BeginSendTo(arg1.Array, arg1.Offset, arg1.Count, arg2, arg3, callback, state), socket.EndSendTo, buffer, socketFlags, remoteEP, null)); }
/// <summary> /// Sends data using the given socket. /// </summary> private void _Send(Socket Socket, IPEndPoint To, Temporary<Data> Data) { byte[] buffer; int offset, size; _Bufferize(Data, out buffer, out offset, out size); Socket.BeginSendTo(buffer, offset, size, SocketFlags.None, To, delegate(IAsyncResult ar) { Socket socket = (ar.AsyncState as Socket); socket.EndSend(ar); if (!this._Receiving) { this._Receiving = true; this._Bind(((IPEndPoint)socket.LocalEndPoint).Port); } }, Socket); }
/// <summary> /// Allows the game to perform any initialization it needs to before starting to run. /// </summary> protected override void Initialize() { // TODO: Add some name detection from forms. strName = "nicktest"; world = new WorldGraphics(); model = new GraphicsModel(); world.SetGraphicsModel(model); //Setup ships for players 1 & 2 (offscreen to start) //GraphicsObject(int id, float x, float y, float radius, float angle, int spriteID, int colorID) GraphicsObject ship1 = new GraphicsObject(1, 0, 0, 16, 0, 1, 5); model.Update(ship1); shipList.Add(ship1); GraphicsObject ship2 = new GraphicsObject(2, -16, -16, 16, 0, 1, 7); model.Update(ship2); shipList.Add(ship2); //Setup planet GraphicsObject planet = new GraphicsObject(3, 400, 300, 32, 0, 201, 0); model.Update(planet); planetList.Add(planet); //******** Networking Stuff ************* //Using UDP sockets clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); IPAddress ipAddress = ipHostInfo.AddressList[0]; Console.WriteLine(ipAddress); //Server is listening on port 1000 IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 11000); epServer = (EndPoint)ipEndPoint; //Get message ready Data msgToSend = new Data(); msgToSend.cmdCommand = Command.Login; msgToSend.strMessage = null; msgToSend.strName = strName; byte[] byteData = msgToSend.ToByte(); //Login to the server clientSocket.BeginSendTo(byteData, 0, byteData.Length, SocketFlags.None, epServer, new AsyncCallback(OnSend), null); byteData = new byte[1024]; //Start listening to the data asynchronously clientSocket.BeginReceiveFrom(byteData, 0, byteData.Length, SocketFlags.None, ref epServer, new AsyncCallback(OnReceive), null); //******** End Networking Stuff ************* base.Initialize(); }
private void Connect(string serverIp, string name) { try { _chatName = name; // Initialize socket. _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); // Initialize server IP. var serverIP = IPAddress.Parse(serverIp); // Initialize the IPEndPoint for the server and use port SERVER_PORT. var server = new IPEndPoint(serverIP, ServerInfo.PORT); // Initialize the EndPoint for the server. _serverEndPoint = server as EndPoint; var state = new StateObject() { Data = new ChatPacket() { ChatName = _chatName, ChatMessage = null, ChatDataIdentifier = DataIdentifier.LogIn }.Serialize() }; // Send data to server. _clientSocket.BeginSendTo(state.Data, 0, state.Data.Length, SocketFlags.None, _serverEndPoint, ar => _clientSocket.EndSend(ar), state); // Initialize data stream. state = new StateObject(); // Begin listening for broadcasts from the server. _clientSocket.BeginReceiveFrom(state.Data, 0, state.Data.Length, SocketFlags.None, ref _serverEndPoint, EndReceive, state); } catch (Exception ex) { Logger.WriteLine("Connection error!"); Logger.WriteLine(ex.Message); } }
private void btnConnect_Click(object sender, EventArgs e) { try { this.name = txtName.Text.Trim(); // Initialise a packet object to store the data to be sent Packet sendData = new Packet(); sendData.ChatName = this.name; sendData.ChatMessage = null; sendData.ChatDataIdentifier = DataIdentifier.LogIn; // Initialise socket this.clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); // Initialise server IP IPAddress serverIP = IPAddress.Parse(txtServerIP.Text.Trim()); // Initialise the IPEndPoint for the server and use port 30000 IPEndPoint server = new IPEndPoint(serverIP, 30000); // Initialise the EndPoint for the server epServer = (EndPoint)server; // Get packet as byte array byte[] data = sendData.GetDataStream(); // Send data to server clientSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, epServer, new AsyncCallback(this.SendData), null); // Initialise data stream this.dataStream = new byte[1024]; // Begin listening for broadcasts clientSocket.BeginReceiveFrom(this.dataStream, 0, this.dataStream.Length, SocketFlags.None, ref epServer, new AsyncCallback(this.ReceiveData), null); } catch (Exception ex) { MessageBox.Show("Connection Error: " + ex.Message, "UDP Client", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
/// <summary> /// Sends an <see cref="ISnmpMessage"/>. /// </summary> /// <param name="message">The <see cref="ISnmpMessage"/>.</param> /// <param name="manager">Manager</param> /// <param name="socket">The socket.</param> public static void SendAsync(this ISnmpMessage message, EndPoint manager, Socket socket) { if (message == null) { throw new ArgumentNullException("message"); } if (socket == null) { throw new ArgumentNullException("socket"); } if (manager == null) { throw new ArgumentNullException("manager"); } var code = message.TypeCode(); if ((code != SnmpType.TrapV1Pdu && code != SnmpType.TrapV2Pdu) && code != SnmpType.ReportPdu) { throw new InvalidOperationException(string.Format( CultureInfo.InvariantCulture, "not a trap message: {0}", code)); } var bytes = message.ToBytes(); socket.BeginSendTo(bytes, 0, bytes.Length, SocketFlags.None, manager, ar => socket.EndSendTo(ar), null); }
public void Send(string ip, int port, byte[] temp_sendbuffer) { socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); socket.BeginSendTo(temp_sendbuffer, 0, temp_sendbuffer.Length, SocketFlags.None, (EndPoint)(new IPEndPoint(IPAddress.Parse(ip), port)), new AsyncCallback(SendTo_Callback), socket); }
public static void sendCommand(IDeviceCommand cmd, IPEndPoint ipEndPoint) { Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); string strcmd = cmd.getCmd(); Debug.WriteLine("=> " + strcmd); byte[] _byteData = Encoding.UTF8.GetBytes(strcmd); clientSocket.BeginSendTo(_byteData, 0, _byteData.Length, SocketFlags.None, ipEndPoint, null, null); //clientSocket.BeginSendTo(_byteData, 0, _byteData.Length, SocketFlags.None, // ipEndPoint, getResponseData, new object[] { clientSocket, cmd }); }
internal void Send(Socket udp,EndPoint sep, string message,int EventType) { DataHandle Handle = new DataHandle(); byte[] data = Handle.HaSe(EventType, message); udp.BeginSendTo(data, 0, data.Length, SocketFlags.None, sep, new AsyncCallback((async) => { }), udp); }
private void button4_Click(object sender, EventArgs e) { Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.IP); byte[] buffer=System.Text.Encoding.Unicode.GetBytes(textBox2.Text); SendRes = socket.BeginSendTo(buffer, 0, buffer.Count(), SocketFlags.None, (EndPoint)new IPEndPoint(IPAddress.Parse("10.2.21.255"), 100), new AsyncCallback(Send_Completed), socket); }
/// <summary> /// Send to asynchronously /// </summary> /// <param name="socket"></param> /// <param name="buffer"></param> /// <param name="offset"></param> /// <param name="size"></param> /// <param name="remoteEndpoint"></param> /// <param name="flags"></param> /// <returns></returns> public static Task <int> SendToAsync(this Socket socket, byte[] buffer, int offset, int size, SocketFlags flags, EndPoint remoteEndpoint) => Task.Factory.FromAsync((c, o) => socket.BeginSendTo( buffer, offset, size, flags, remoteEndpoint, c, o), socket.EndSendTo, TaskCreationOptions.DenyChildAttach);
System.IAsyncResult Utils.Wrappers.Interfaces.ISocket.BeginSendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, System.Net.EndPoint remoteEP, System.AsyncCallback callback, object state) { return(InternalSocket.BeginSendTo(buffer, offset, size, socketFlags, remoteEP, callback, state)); }
private bool UdpSend(Socket client) { if (client == null) { client = Sockets; } EndPoint ep = (EndPoint)RemoteIPEP; client.BeginSendTo(sendByte, 0, sendByte.Length, SocketFlags.None, ep, new AsyncCallback(UdpSendAC), null); return ZBool; }