private void BroadcastCallback(IAsyncResult ar)
{
try
{
int len = broadcaster.EndSendTo(ar);
lock (bcStopLock)
{
if (isBCStop)
{
return;
}
}
if (len == bcBuf.Length)
{
//wait a moment
Thread.Sleep(BROADCAST_INTERVAL);
}
broadcaster?.BeginSendTo(bcBuf, 0, bcBuf.Length, SocketFlags.None,
bcEP, new AsyncCallback(BroadcastCallback), null);
}
catch (Exception e)
{
Logging.Error(e);
}
}
public void SendTo(byte[] dataBuf, IPEndPoint targetEP)
{
try
{
udpSocket?.BeginSendTo(dataBuf, 0, dataBuf.Length, SocketFlags.None,
targetEP, new AsyncCallback(SendToCallback), targetEP);
}
catch (Exception e)
{
Logging.Error(e);
}
}
public Result BroadcastMessage(byte[] message)
{
try
{
_mainUdpSocket?.BeginSendTo(message, 0, message.Length, SocketFlags.None, udpClientEP, new AsyncCallback(UdpSendCallback), _mainUdpSocket);
return(Result.Ok());
}
catch (ObjectDisposedException)
{
return(Result.Fail("Server BroadcastMessage: socket has been closed"));
}
catch (SocketException se)
{
return(Result.Fail($"Server BroadcastMessage, socket: [{se.ErrorCode}], [{se.SocketErrorCode}] - {se.Message}"));
}
catch (Exception e)
{
return(Result.Fail($"Server BroadcastMessage, unexpected: {e.Message}"));
}
}
//Send the string out to server
private void SendNMEA()
{
try
{
// Get packet as byte array
byte[] byteData = Encoding.ASCII.GetBytes(sbSendText.ToString());
if (byteData.Length != 0)
{
// Send packet to the server
clientSocket.BeginSendTo(byteData, 0, byteData.Length, SocketFlags.None, epServer, new AsyncCallback(SendData), null);
}
//not really necessary but does show what was in buffer that was sent
txtNMEA.Text = (Encoding.ASCII.GetString(byteData));
}
catch (Exception ex)
{
MessageBox.Show("Send Error: " + ex.Message, "UDP Client", MessageBoxButtons.OK, MessageBoxIcon.Error);
} // Check we are connected
}
/*
* Send a message to the remote party.
*/
private void SendMessage(Command cmd, EndPoint sendToEP)
{
try
{
//Create the message to send.
Data msgToSend = new Data();
msgToSend.strName = Globals.currentUserLogin; //txtName.Text; //Name of the user.
msgToSend.cmdCommand = cmd; //Message to send.
byte[] message = msgToSend.ToByte();
//Send the message asynchronously.
clientSocket.BeginSendTo(message, 0, message.Length, SocketFlags.None, sendToEP, new AsyncCallback(OnSend), null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, "VoiceChat-SendMessage ()", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
}
}
public void Send(IPEndPoint address, byte[] data, bool async = true)
{
try {
if (async)
{
fSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, address, (ar) => {
try {
fSocket.EndSendTo(ar);
} catch (Exception ex) {
fLogger.WriteError("Send.1(" + address + ")", ex);
}
}, null);
}
else
{
fSocket.SendTo(data, 0, data.Length, SocketFlags.None, address);
}
} catch (Exception ex) {
fLogger.WriteError("Send()", ex);
}
}
private void sendBtn_Click(object sender, EventArgs e)
{
try
{
Packet sendData = new Packet();
sendData.ChatName = clientName;
sendData.ChatMessage = messageText.Text.Trim();
sendData.ChatDataIdentifier = DataIdentifier.Message;
byte[] byteData = sendData.GetDataStream();
clientSocket.BeginSendTo(byteData, 0, byteData.Length, SocketFlags.None, serverEp, new AsyncCallback(SendData), null);
messageText.Text = string.Empty;
}
catch (ObjectDisposedException ex)
{
}
catch (Exception ex)
{
MessageBox.Show("Send Error : " + ex.Message, "UDP Client", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Sends a Netbios Name Service packet asynchronously
/// </summary>
/// <param name="packet">Netbios Name Service packet to send</param>
/// <param name="address">Target address to send the packet to</param>
/// <param name="timeOutMilliseconds">
/// Maximum time in milliseconds to wait for the send operation to finish. If it takes longer, the target IP address
/// most likely does not exist in a local subnet (although the address is part of a local subnet) so that the ARP
/// protocol is not able to find the MAC address for the given IP address.
/// </param>
/// <returns>
/// A <see cref="Task"/> that completes with result = <c>true</c> when the packet was successfully sent or
/// with result = <c>false</c> if the send operation was not successful witin the given timeout.
/// </returns>
public async Task <bool> SendPacketAsync(NbNsPacketBase packet, IPAddress address, int timeOutMilliseconds = SEND_TIMEOUT)
{
if (packet == null)
{
throw new ArgumentNullException("packet");
}
if (address == null)
{
throw new ArgumentNullException("address");
}
var endPoint = new IPEndPoint(address, TARGET_PORT);
var tcs = new TaskCompletionSource <int>();
try
{
_socket.BeginSendTo(packet, 0, packet.Length, SocketFlags.None, endPoint, asynchronousResult =>
{
var t = (TaskCompletionSource <int>)asynchronousResult.AsyncState;
try
{
t.TrySetResult(_socket.EndSendTo(asynchronousResult));
}
catch (Exception)
{
t.TrySetResult(0);
}
}, tcs);
}
catch (Exception)
{
return(false);
}
if (await Task.WhenAny(tcs.Task, Task.Delay(timeOutMilliseconds)) != tcs.Task)
{
return(false);
}
// The send operation was successful if as many bytes as are contained in the packet were actually sent.
return(packet.Length == await tcs.Task);
}
private void OnSendComplete(IAsyncResult asyncResult)
{
Socket s = (Socket)asyncResult.AsyncState;
try {
int bytes = s.EndSend(asyncResult);
if (bytes <= 0)
{
Dispose(false);
return;
}
_NextCheckActivity = Timing.Ticks + MsBeforeDisconnectNormal;
SendQueue.Gram gram;
lock (_SendQueue) {
gram = _SendQueue.Dequeue();
if (gram == null && _SendQueue.IsFlushReady)
{
gram = _SendQueue.CheckFlushReady();
}
}
if (gram != null)
{
try {
s.BeginSendTo(gram.Buffer, 0, gram.Length, SocketFlags.None, _ClientEndPoint, _OnSendComplete, _Socket);
}
catch (Exception ex) {
TraceException(ex);
Dispose(false);
}
}
else
{
lock (_SendLockMutex)
_sending = false;
}
}
catch (Exception) {
Dispose(false);
}
}
//connect and set up UDP to broadcast
private void FormSim_Load(object sender, EventArgs e)
{
// Initialise delegate
displayMessageDelegate = new DisplayMessageDelegate(DisplayMessage);
try
{
ipAddress = tboxIP.Text.Trim();
// Initialise socket
clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
// Initialise server IP
IPAddress serverIP = IPAddress.Parse(ipAddress);
// Initialise the IPEndPoint for the server and use port 30000
epServer = new IPEndPoint(serverIP, (int)nudPort.Value);
// Get packet as byte array
byte[] data = Encoding.ASCII.GetBytes("Connecting");
// Send data to server
clientSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, epServer, new AsyncCallback(SendData), null);
// Initialise data stream
buffer = new byte[1024];
timer1.Enabled = true;
// Begin listening for broadcasts
clientSocket.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref epServer, new AsyncCallback(ReceiveData), null);
//start allowing nmea to be sent
isConnected = true;
}
catch (Exception ex)
{
MessageBox.Show("Connection Error: " + ex.Message, "UDP Client", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void _timer_get2300Tag(object sender, EventArgs e)
{
__udpServer.Manualstate.WaitOne();
__udpServer.Manualstate.Reset();
string str = __udpServer.sbuilder.ToString();
__udpServer.sbuilder.Remove(0, str.Length);
if (this.__reader_info.sendType == ReaderInfo.sendTypeUDP)
{
byte[] byteData = Encoding.UTF8.GetBytes(str);
foreach (EndPoint ep in this.endpoint_list)
{
clientSocket.BeginSendTo(byteData, 0,
byteData.Length, SocketFlags.None,
ep, new AsyncCallback(OnSend), null);
}
string log = "接收到读写器数据";
this.appendLog(log);
}
else
{
List <TagInfo> taglist = __2300helper.getTagList();
foreach (TagInfo ti in taglist)
{
string log = "检测到标签 " + ti.epc;
this.appendLog(log);
this.addTagsToServer(ti.epc);
}
__2300helper.ParseDataToTag(str);
if (str != null && str.Length > 0)
{
//Debug.WriteLine(
// string.Format(". _timer_get2300Tag -> string = {0}"
// , str));
}
}
__udpServer.Manualstate.Set();
}
private void OnSend(IAsyncResult ar)
{
try
{
Socket.EndSend(ar);
}
catch (ObjectDisposedException)
{
return;
}
catch (SocketException ex)
{
// Fail
if (ex.SocketErrorCode != SocketError.ConnectionRefused)
{
Assert.Null(ex.Message);
}
}
catch (Exception ex)
{
// Fail
Assert.Null(ex.Message);
}
System.Threading.Thread.Sleep(WaitTime);
try
{
Socket.BeginSendTo(RecvBuf, 0, RecvBuf.Length, SocketFlags.None, remoteEP, new AsyncCallback(OnSend), null);
}
catch (ObjectDisposedException)
{
return;
}
catch (Exception ex)
{
// Fail
Assert.Null(ex.Message);
}
}
private void btnConectar_Click(object sender, EventArgs e)
{
try
{
//seteo en la variable el nombre ingresado
nombre = txtNombre.Text.Trim();
//se crean los paquetes iniciales
Paquete paqueteInicio = new Paquete();
paqueteInicio.NombreChat = nombre;
paqueteInicio.MensajeChat = null;
paqueteInicio.IdentificadorChat = IdentificadorDato.Conectado;
//se instancia socket, con el constructor que acepta como parámetros de entrada el esquema de
//direccionamiento, el tipo de socket, y el tipo de protocolo que en este caso es udp
socketCliente = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
//se setea la dirección ip del servidor
IPAddress servidorIP = IPAddress.Parse(txtServidor.Text.Trim());
//se crea un punto remoto con la dirección ip del servidor y el puerto de escucha
IPEndPoint puntoRemoto = new IPEndPoint(servidorIP, 30000);
epServidor = (EndPoint)puntoRemoto;
//se obtiene el arreglo de bytes de paquete inicial
byte[] buferTx = paqueteInicio.ObtenerArregloBytes();
//socket para envío de datos
socketCliente.BeginSendTo(buferTx, 0, buferTx.Length, SocketFlags.None, epServidor, new
//delegado al método ProcesarEnviar cuando se intenta la conexión
AsyncCallback(ProcesarEnviar), null);
//se setea el tamaño del buffer de recepción
buferRx = new byte[1024];
//se recibe asincrónicamente los datos
socketCliente.BeginReceiveFrom(buferRx, 0, buferRx.Length, SocketFlags.None, ref epServidor, new
//se hace referencia al método ProcesarRecibir cuando finalice la entrega asincrónica
AsyncCallback(this.ProcesarRecibir), null);
}
catch (Exception ex)
{
//si se presenta un error se muestra por consola
MessageBox.Show("Error al conectarse: " + ex.Message, "Cliente UDP",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
/// <summary>
/// Sends the datagram with the asynchronous mode.
/// </summary>
/// <param name="sendBuffer">The send buffer.</param>
/// <param name="sendBufferSize">Size of the send buffer.</param>
public override void SendDatagram(byte[] sendBuffer, int sendBufferSize)
{
lock (mutex)
{
try
{
int bufferOffset = 0;
// Sends data asynchronously to a socket.
if (socket != null)
{
socket.BeginSendTo(sendBuffer, bufferOffset, sendBufferSize, SocketFlags.None, this.remoteEndPoint, this.EndSendDatagram, this);
}
}
catch (System.Exception e)
{
this.OnClientTeardown();
this.OnExceptionOccurred(e);
Utils.OutputMessage(false, MsgLevel.Error, "ClientSocketUdp -- SendDatagram", e.Message);
}
}
}
public static void Broadcast(string data, int port)
{
Debug.WriteLine("Broadcast => " + data);
Socket broadcastSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Dgram, ProtocolType.Udp);
broadcastSocket.EnableBroadcast = true;
IPEndPoint iep = new IPEndPoint(IPAddress.Broadcast, port);
byte[] byteData = System.Text.Encoding.UTF8.GetBytes(data);
try
{
broadcastSocket.BeginSendTo(byteData, 0,
byteData.Length, SocketFlags.None,
iep, null, null);
}
catch (System.Exception ex)
{
Debug.WriteLine("Broadcast => " + ex.Message);
}
}
/*
* Send a message to the remote party.
*/
private void SendMessage(Command cmd, EndPoint sendToEP)
{
try
{
//Create the message to send.
Data msgToSend = new Data();
msgToSend.strName = Nickname; //Name of the user.
msgToSend.cmdCommand = cmd; //Message to send.
msgToSend.vocoder = vocoder; //Vocoder to be used.
byte[] message = msgToSend.ToByte();
//Send the message asynchronously.
clientSocket.BeginSendTo(message, 0, message.Length, SocketFlags.None, sendToEP, new AsyncCallback(OnSend), null);
}
catch (Exception ex)
{
cGlobalVars.AddLogChat("VoiceChat-SendMessage > " + ex.Message);
//MessageBox.Show(ex.Message, "VoiceChat-SendMessage ()", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public override Task <SocketError> SendAsync(SIPEndPoint dstEndPoint, byte[] buffer, string connectionIDHint)
{
if (dstEndPoint == null)
{
throw new ArgumentException("dstEndPoint", "An empty destination was specified to Send in SIPUDPChannel.");
}
else if (buffer == null || buffer.Length == 0)
{
throw new ArgumentException("buffer", "The buffer must be set and non empty for Send in SIPUDPChannel.");
}
try
{
IPEndPoint dstIPEndPoint = dstEndPoint.GetIPEndPoint();
if (m_sendFailures.ContainsKey(dstEndPoint.GetIPEndPoint()))
{
return(Task.FromResult(SocketError.ConnectionRefused));
}
else
{
m_udpSocket.BeginSendTo(buffer, 0, buffer.Length, SocketFlags.None, dstIPEndPoint, EndSendTo, dstEndPoint);
return(Task.FromResult(SocketError.Success));
}
}
catch (ObjectDisposedException) // Thrown when socket is closed. Can be safely ignored.
{
return(Task.FromResult(SocketError.Disconnecting));
}
catch (SocketException sockExcp)
{
return(Task.FromResult(sockExcp.SocketErrorCode));
}
catch (Exception excp)
{
logger.LogError($"Exception SIPUDPChannel.SendAsync. {excp}");
return(Task.FromResult(SocketError.Fault));
}
}
/// <summary>
/// Reply to a search from a user via udp
/// (active connection of peer user required)
/// </summary>
/// <param name="result_name">the filename of the share found</param>
/// <param name="filesize">the filesize of the share</param>
/// <param name="hub">the hub the user is connected to</param>
/// <param name="search">a whole lot of parameters of the search initiated by a remote user (including ip and port,which we will need here)</param>
public void SearchReply(string result_name, long filesize, Hub hub, Hub.SearchParameters search)
{
try
{
string temp_hub = hub.Name;
if (search.HasTTH)
{
temp_hub = "TTH:" + search.tth;
}
string reply = "$SR " + hub.Nick + " " + result_name + (char)0x05 + filesize + " 1/1" + (char)0x05 + temp_hub + " (" + hub.IP + ":" + hub.Port + ")|";
Console.WriteLine("Replying to active search: " + reply);
IPEndPoint udp_reply_endpoint = new IPEndPoint(IPAddress.Parse(search.ip), search.port);
//EndPoint temp_receive_from_endpoint = (EndPoint)receive_from_endpoint;
byte[] send_bytes = System.Text.Encoding.Default.GetBytes(reply);
udp_socket.BeginSendTo(send_bytes, 0, send_bytes.Length, SocketFlags.None, udp_reply_endpoint, new AsyncCallback(SearchReplyCallback), udp_socket);
}
catch (Exception ex)
{
Console.WriteLine("Exception during sending of SearchReply to: " + search.ip + ":" + search.port + " : " + ex.Message);
}
}
/// <summary>Used internally by the netcode to send raw packets directly to the socket.</summary>
/// <param name="remote">Remote address to send to.</param>
/// <param name="buffer">Array to read from.</param>
/// <param name="offset">Array offset to read from.</param>
/// <param name="count">Number of bytes to read.</param>
/// <returns>Task that returns number of bytes sent.</returns>
internal async Task <int> SendSocketAsync(IPEndPoint remote, byte[] buffer, int offset, int count)
{
try {
// Convert remote address if needed
if (Socket.AddressFamily == AddressFamily.InterNetworkV6)
{
if (remote.AddressFamily != AddressFamily.InterNetworkV6)
{
remote = new IPEndPoint(remote.Address.MapToIPv6(), remote.Port);
}
}
else if (remote.Address.IsIPv4MappedToIPv6)
{
remote = new IPEndPoint(remote.Address.MapToIPv4(), remote.Port);
}
// Send packet and wait for completion
TaskCompletionSource <int> tcs = new TaskCompletionSource <int>();
Socket.BeginSendTo(buffer, offset, count, SocketFlags.None, remote, result => {
try {
tcs.TrySetResult(Socket.EndSendTo(result));
} catch (Exception e) {
tcs.TrySetException(e);
}
}, null);
count = await tcs.Task;
// Increment statistics
Statistics.SetSocketSendTicks(Ticks);
Statistics.IncrementSocketSendCount();
Statistics.AddSocketSendBytes(count);
// Return number of bytes sent
return(count);
} catch (Exception exception) {
Listener.OnHostException(remote, exception);
throw;
}
}
/// <summary>
/// Sends data from the listener socket.
/// </summary>
/// <param name="bytes">The bytes to send.</param>
/// <param name="endPoint">The endpoint to send to.</param>
internal void SendData(byte[] bytes, int length, EndPoint endPoint)
{
if (length > bytes.Length)
{
return;
}
#if DEBUG
if (TestDropRate > 0)
{
if (Interlocked.Increment(ref dropCounter) % TestDropRate == 0)
{
return;
}
}
#endif
try
{
socket.BeginSendTo(
bytes,
0,
length,
SocketFlags.None,
endPoint,
SendCallback,
null
);
}
catch (SocketException e)
{
throw new HazelException("Could not send data as a SocketException occurred.", e);
}
catch (ObjectDisposedException)
{
//Keep alive timer probably ran, ignore
return;
}
}
//sends byte array
public void SendUDPMessage(byte[] byteData)
{
if (isUDPSendConnected)
{
try
{
IPEndPoint EndPt = new IPEndPoint(epIP, SendToPort);
// Send packet to the zero
if (byteData.Length != 0)
{
sendSocket.BeginSendTo(byteData, 0, byteData.Length, SocketFlags.None, EndPt, new AsyncCallback(SendData), null);
}
//mf.WriteEvent("sent udp message to control box " + byteData[2].ToString());
}
catch (Exception e)
{
mf.Tls.WriteErrorLog("Sending UDP Message" + e.ToString());
mf.Tls.TimedMessageBox("Send Error", e.Message);
}
}
}
private async void Run()
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
EndPoint endPoint = new IPEndPoint(IPAddress.Loopback, 10_000);
while (true)
{
Image image = new Bitmap(await GetScreen());
MemoryStream memoryStream = new MemoryStream();
image.Save(memoryStream, ImageFormat.Jpeg);
byte[] send = memoryStream.ToArray();
int len = 0;
int sended = 0;
while (sended != send.Length)
{
if (sended < send.Length - 500)
{
len = await Task.Factory.FromAsync(s.BeginSendTo(send, sended, 500, SocketFlags.None, endPoint, null, null),
s.EndSendTo);
sended += 500;
}
else
{
len = await s.SendTo(send, 500, send.Length - sended, SocketFlags.None, endPoint);
sended += send.Length - sended;
}
}
await s.SendTo(send, 0, 0, SocketFlags.None, endPoint);
//Thread.Sleep(interval);
await Task.Delay(interval);
memoryStream.Close();
}
}
/// <summary>
/// This method is the process used by the methods SendTo.
/// This method can send a message to a given machine. The IPEndPoint corresponding to the machine
/// is specified by the (<paramref name="target"/>) parameter.
/// The message is specified in the (<paramref name="text"/>) parameter.
/// <example>For example:
/// <code>
/// UdpSocket socket = new UdpSocket();
/// socket.Start("127.0.0.1", 27000);
/// socket.SendTo("127.0.0.1", 27000, "Hello");
/// </code>
/// This code creat a new udpSocket and use it to send the message "Hello" to itself.
/// </example>
/// </summary>
///<param name="target">The IPEndPoint used to bind the socket on</param>
///<param name="text">The message to send as a string </param>
private void SendToProcess(IPEndPoint target, string text)
{
if (!IsActive)
{
return;
}
try
{
var data = Encoding.ASCII.GetBytes(text);
var sendState = new State(_bufSize);
_socket.BeginSendTo(data, 0, data.Length, SocketFlags.None, target, (ar) =>
{
var so = (State)ar.AsyncState;
try
{
var bytes = _socket.EndSend(ar);
if (_verbose)
{
Console.WriteLine("SEND: {0}, {1}", bytes, text);
}
}
catch
{
if (_verbose)
{
Console.WriteLine("Unable to send message to: {0}", target);
}
}
}, sendState);
}
catch
{
if (_verbose)
{
Console.WriteLine("Destination unavailable");
}
}
}
private void btnLogin_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.strName = strName;
msgToSend.strMessage = null;
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);
}
ClientChat_from clientChat_From = new ClientChat_from();
clientChat_From.Show();
this.Hide(); //藏起來
}
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
if (txtServerIP.Text == "Domo")
{
string serverIp = "127.0.0.1";
IPAddress ipAddress = IPAddress.Parse(serverIp);
//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);
}
else
{
MessageBox.Show("Wrong group name!!!!");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "SGSclient", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void SendBytes(IPEndPoint endPoint, byte[] data)
{
PacketSending(endPoint, data, data.Length);
try
{
_socket.BeginSendTo(data, 0, data.Length, SocketFlags.None, endPoint, (ar) =>
{
try
{
StateObject so = (StateObject)ar.AsyncState;
int bytes = _socket.EndSend(ar);
}
catch (Exception ex)
{
OnSocketError?.Invoke(endPoint, ex);
}
}, state);
}
catch (Exception ex)
{
OnSocketError?.Invoke(endPoint, ex);
}
}
private static void Send(Socket handler, List <ReturnRecentItems> items, StateObject state)
{
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.7"), 11000);
// Convert the string data to byte data using ASCII encoding.
foreach (var data in items)
{
byte[] byteData = Encoding.ASCII.GetBytes(data.ValueOfItem.ToString());
handler.BeginSendTo(byteData,
0,
byteData.Length,
0,
localEndPoint,
SendCallback,
state);
//handler.BeginSend(byteData, 0, byteData.Length, 0,
//new AsyncCallback(SendCallback), handler);
}
// Begin sending the data to the remote device.
}
private void btnIngresar_Click(object sender, EventArgs e)
{
try
{
nombre = txtNombre.Text.Trim();
Paquete paqueteInicio = new Paquete();
paqueteInicio.NombreChat = nombre;
paqueteInicio.MensajeChat = null;
paqueteInicio.IdentificadorChat = Paquete.IdentificadorDato.Conectado;
socketCliente = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
IPAddress servidorIP = IPAddress.Parse(txtServidor.Text.Trim());
IPEndPoint puntoRemoto = new IPEndPoint(servidorIP, 30000);
epServidor = (EndPoint)puntoRemoto;
byte[] buferTx = paqueteInicio.ObtenerArregloBytes();
socketCliente.BeginSendTo(buferTx, 0, buferTx.Length, SocketFlags.None, epServidor, new AsyncCallback(ProcesarEnviar), null);
buferRx = new byte[1024];
socketCliente.BeginReceiveFrom(buferRx, 0, buferRx.Length, SocketFlags.None, ref epServidor, new AsyncCallback(this.ProcesarRecibir), null);
}
catch (Exception ex)
{
MessageBox.Show("Error al conectarse: " + ex.Message, "Cliente UDP", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void SendUDPMessage(string message)
{
if (isSendConnected)
{
try
{
// Get packet as byte array
byte[] byteData = Encoding.ASCII.GetBytes(message);
if (byteData.Length != 0)
{
// Send packet to the zero
sendSocket.BeginSendTo(byteData, 0, byteData.Length, SocketFlags.None, epAutoSteer, new AsyncCallback(SendData), null);
}
}
catch (Exception e)
{
WriteErrorLog("Sending UDP Message" + e.ToString());
MessageBox.Show("Send Error: " + e.Message, "UDP Client", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// <inheritdoc />
protected override void WriteBytesToConnection(byte[] bytes)
{
try
{
socket.BeginSendTo(
bytes,
0,
bytes.Length,
SocketFlags.None,
RemoteEndPoint,
HandleSendTo,
null);
}
catch (NullReferenceException) { }
catch (ObjectDisposedException)
{
// Already disposed and disconnected...
}
catch (SocketException ex)
{
DisconnectInternal(HazelInternalErrors.SocketExceptionSend, "Could not send data as a SocketException occurred: " + ex.Message);
}
}
private void DualModeBeginSendTo_EndPointToHost_Helper(IPAddress connectTo, IPAddress listenOn, bool dualModeServer, bool expectedToTimeout = false)
{
int port;
Socket client = new Socket(SocketType.Dgram, ProtocolType.Udp);
using (SocketUdpServer server = new SocketUdpServer(_log, listenOn, dualModeServer, out port))
{
// Send a few packets, in case they aren't delivered reliably.
for (int i = 0; i < Configuration.UDPRedundancy; i++)
{
IAsyncResult async = client.BeginSendTo(new byte[1], 0, 1, SocketFlags.None, new IPEndPoint(connectTo, port), null, null);
int sent = client.EndSendTo(async);
Assert.Equal(1, sent);
}
bool success = server.WaitHandle.WaitOne(expectedToTimeout ? Configuration.FailingTestTimeout : Configuration.PassingTestTimeout); // Make sure the bytes were received
if (!success)
{
throw new TimeoutException();
}
}
}
[Fact] // Base case
// "The parameter remoteEP must not be of type DnsEndPoint."
public void Socket_BeginSendToDnsEndPoint_Throws()
{
Socket socket = new Socket(SocketType.Dgram, ProtocolType.Udp);
Assert.Throws<ArgumentException>(() =>
{
socket.BeginSendTo(new byte[1], 0, 1, SocketFlags.None, new DnsEndPoint("localhost", UnusedPort), null, null);
});
}
[Fact] // Base case
// "The system detected an invalid pointer address in attempting to use a pointer argument in a call"
public void Socket_BeginSendToV4IPEndPointToV4Host_Throws()
{
Socket socket = new Socket(SocketType.Dgram, ProtocolType.Udp);
socket.DualMode = false;
Assert.Throws<SocketException>(() =>
{
socket.BeginSendTo(new byte[1], 0, 1, SocketFlags.None, new IPEndPoint(IPAddress.Loopback, UnusedPort), null, 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 void Socket_BeginSendToDnsEndPoint_ArgumentException()
{
using (Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
Assert.Throws<ArgumentException>(() =>
{
sock.BeginSendTo(new byte[10], 0, 0, SocketFlags.None, new DnsEndPoint("localhost", UnusedPort), null, null);
});
}
}
private void DualModeBeginSendTo_EndPointToHost_Helper(IPAddress connectTo, IPAddress listenOn, bool dualModeServer)
{
int port;
Socket client = new Socket(SocketType.Dgram, ProtocolType.Udp);
using (SocketUdpServer server = new SocketUdpServer(listenOn, dualModeServer, out port))
{
IAsyncResult async = client.BeginSendTo(new byte[1], 0, 1, SocketFlags.None, new IPEndPoint(connectTo, port), null, null);
int sent = client.EndSendTo(async);
Assert.Equal(1, sent);
bool success = server.WaitHandle.WaitOne(100); // Make sure the bytes were received
if (!success)
{
throw new TimeoutException();
}
}
}