In Your .h File
#define RECEIVE_BUFFER_SIZE 1500
private: Socket ^serverSocket;
//-------------------------------------
//----- CLASS FOR RECEIVE SOCKETS -----
//-------------------------------------
ref class StateObject
{
public:
property int bufSize;
property Socket ^workSocket;
property array<unsigned char>^ message;
StateObject(Socket^ sock, int bufsize)
{
workSocket = sock;
bufSize = bufsize;
message = gcnew array<unsigned char>(bufsize);
}
};
Create Socket
//----- SETUP UDP ASYNCHRONOUS RECEIVE ----- try { //----- CREATE UDP SOCKET AND BIND TO LOCAL PORT ----- serverSocket = gcnew Socket(AddressFamily::InterNetwork, SocketType::Dgram, ProtocolType::Udp); IPEndPoint ^ipEndPoint = gcnew IPEndPoint(IPAddress::Any, LOCAL_UDP_SOCKET); //Assign the any IP of the machine and listen on port number serverSocket->Bind(ipEndPoint); //Bind required if not sending data (sending does bind for you) //----- CREATE ASYNCHRONOUS RECEIVE HANDLER -----myClassNameIPEndPoint ^ipeSender1 = gcnew IPEndPoint(IPAddress::Any, 0); EndPoint ^epSender1 = (EndPoint^)(ipeSender1); //The epSender identifies the incoming clients StateObject ^so1 = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE); //Start reciving data using BeginReceiveFrom //(Use BeginReceiveFrom not BeginReceive so we can determin the sender when we receive a packet - only way when using UDP. If you don't care who the sender is you could use BeginReceive if you wanted, but no particular reason you need to) serverSocket->BeginReceiveFrom (so1->message, 0, so1->bufSize, //Byte array to store received data, offset into the buffer to start sotring the data, number of bytes to receive, SocketFlags::None, epSender1, //bitwise combination of the SocketFlags values, EndPoint that represents the source of the data. gcnew AsyncCallback(this, &myClassName::ReceiveCallback), so1); //AsyncCallback delegate, object containing state information for this request //UDP will also drop packets upon receipt if, even momentarily, BeginReceiveFrom is not active on the socket. //There is a short time between acceptance of a packet and calling another BeginReceiveFrom. Even if this call were the first one in MessageReceivedCallback, there's a //still short period when the app isn't listening. A simple solution is to activate several instances of BeginReceiveFrom, each with a separate buffer to hold received //packets. //CREATE ANOTHER ASYNCHRONOUS RECEIVE HANDLER IPEndPoint^ ipeSender2 = gcnew IPEndPoint(IPAddress::Any, 0); EndPoint^ epSender2 = (EndPoint^)(ipeSender2); StateObject^ so2 = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE); serverSocket->BeginReceiveFrom (so2->message, 0, so2->bufSize, SocketFlags::None, epSender2, gcnew AsyncCallback(this, &myClassName::ReceiveCallback), so2); //CREATE ANOTHER ASYNCHRONOUS RECEIVE HANDLER IPEndPoint^ ipeSender3 = gcnew IPEndPoint(IPAddress::Any, 0); EndPoint^ epSender3 = (EndPoint^)(ipeSender3); StateObject^ so3 = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE); serverSocket->BeginReceiveFrom (so3->message, 0, so3->bufSize, SocketFlags::None, epSender3, gcnew AsyncCallback(this, &myClassName::ReceiveCallback), so3); //CREATE ANOTHER ASYNCHRONOUS RECEIVE HANDLER IPEndPoint^ ipeSender4 = gcnew IPEndPoint(IPAddress::Any, 0); EndPoint^ epSender4 = (EndPoint^)(ipeSender4); StateObject^ so4 = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE); serverSocket->BeginReceiveFrom (so4->message, 0, so4->bufSize, SocketFlags::None, epSender4, gcnew AsyncCallback(this, &myClassName::ReceiveCallback), so4); //CREATE ANOTHER ASYNCHRONOUS RECEIVE HANDLER IPEndPoint^ ipeSender5 = gcnew IPEndPoint(IPAddress::Any, 0); EndPoint^ epSender5 = (EndPoint^)(ipeSender5); StateObject^ so5 = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE); serverSocket->BeginReceiveFrom (so5->message, 0, so5->bufSize, SocketFlags::None, epSender5, gcnew AsyncCallback(this, &myClassName::ReceiveCallback), so5); //CREATE ANOTHER ASYNCHRONOUS RECEIVE HANDLER IPEndPoint^ ipeSender6 = gcnew IPEndPoint(IPAddress::Any, 0); EndPoint^ epSender6 = (EndPoint^)(ipeSender6); StateObject^ so6 = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE); serverSocket->BeginReceiveFrom (so6->message, 0, so6->bufSize, SocketFlags::None, epSender6, gcnew AsyncCallback(this, &myClassName::ReceiveCallback), so6); //CREATE ANOTHER ASYNCHRONOUS RECEIVE HANDLER IPEndPoint^ ipeSender7 = gcnew IPEndPoint(IPAddress::Any, 0); EndPoint^ epSender7 = (EndPoint^)(ipeSender7); StateObject^ so7 = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE); serverSocket->BeginReceiveFrom (so7->message, 0, so7->bufSize, SocketFlags::None, epSender7, gcnew AsyncCallback(this, &myClassName::ReceiveCallback), so7); //CREATE ANOTHER ASYNCHRONOUS RECEIVE HANDLER IPEndPoint^ ipeSender8 = gcnew IPEndPoint(IPAddress::Any, 0); EndPoint^ epSender8 = (EndPoint^)(ipeSender8); StateObject^ so8 = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE); serverSocket->BeginReceiveFrom (so8->message, 0, so8->bufSize, SocketFlags::None, epSender8, gcnew AsyncCallback(this, &myClassName::ReceiveCallback), so8); } catch (Exception ^e) { }
Receive Handler
//*********************************
//*********************************
//********** UDP RECEIVE **********
//*********************************
//*********************************
void myClassName::ReceiveCallback(System::IAsyncResult^ iar)
{
int byteId;
UInt16 OpCode;
String ^RxFromIp;
UInt16 RxFromPort;
int ReTries;
StateObject^ so = (StateObject^)iar->AsyncState;
Socket^ client = so->workSocket;
//-----------------------------------
//----- PROCESS RECEIVED PACKET -----
//-----------------------------------
try
{
//Create a temporary EndPoint to pass to EndReceiveFrom (we have to do this to be able to get the RemoteEndPoint information - only way when using UDP)
IPEndPoint^ sender = gcnew IPEndPoint( IPAddress::Any,0 );
EndPoint^ tempRemoteEP = safe_cast<EndPoint^>(sender);
int rcv;
if ((rcv = client->EndReceiveFrom(iar, tempRemoteEP )) > 0) //Complete BeginReceive operation and get the message
{
byteId = 0;
if (
(so->message[byteId++] == 'H') &&
(so->message[byteId++] == 'e') &&
(so->message[byteId++] == 'l') &&
(so->message[byteId++] == 'l') &&
(so->message[byteId++] == 'o')
)
{
//------------------------
//----- VALID PACKET -----
//------------------------
//Get OpCode
OpCode = Convert::ToInt32(so->message[byteId++]) << 8;
OpCode |= Convert::ToInt32(so->message[byteId++]);
//----- GET SENDERS IP ADDRESS -----
SocketAddress^ remoteDeviceAddress = tempRemoteEP->Serialize();
if (remoteDeviceAddress->Family == AddressFamily::InterNetwork)
{
//IPv4 Address
RxFromPort = Convert::ToUInt16(remoteDeviceAddress[2]) << 8; //Port number is in bytes 2:3
RxFromPort |= Convert::ToUInt16(remoteDeviceAddress[3]);
RxFromIp = remoteDeviceAddress[4] + "." + remoteDeviceAddress[5] + "." + remoteDeviceAddress[6] + "." + remoteDeviceAddress[7]; //IP Address in bytes 4:7
}
//else if (remoteDeviceAddress->Family == AddressFamily::InterNetworkV6)
//{
// //IPv6 Address
//}
else
{
RxFromIp = "0.0.0.0";
OpCode = 0; //Dump the packet
}
switch (OpCode)
{
case 0x1234:
//-----------------------
//-----------------------
//----- OPCODE 1234 -----
//-----------------------
//-----------------------
SomeVariable = Convert::ToInt32(so->message[byteId++]) << 8;
SomeVariable |= Convert::ToInt32(so->message[byteId++]);
SomeString = Convert::ToString(so->message[byteId++]) + ".";
SomeString += Convert::ToString(so->message[byteId++]) + ".";
SomeString += Convert::ToString(so->message[byteId++]) + ".";
SomeString += Convert::ToString(so->message[byteId++]);
break;
} //switch (OpCode)
}
}
}
catch (Exception ^e)
{
}
finally
{
//----------------------------------
//----- SETUP FOR NEXT RECEIVE -----
//----------------------------------
ReTries = 50; //Limit the while loop just in case
while (ReTries) //We use a while loop as BeginReceiveFrom can occasionally cause a SocketException error when there is lots of receive activity. Without this the BeginReceiveFrom is lost causing no receive anymore once they are all used up.
{
ReTries--;
try
{
//----- CREATE ANOTHER ASYNCHRONOUS RECEIVE HANDLER TO REPLACE THIS ONE JUST USED -----
IPEndPoint^ ipeSender = gcnew IPEndPoint(IPAddress::Any, 0);
EndPoint^ epSender = (EndPoint^)(ipeSender); //The epSender identifies the incoming clients
so = gcnew StateObject(serverSocket, RECEIVE_BUFFER_SIZE);
serverSocket->BeginReceiveFrom (so->message, 0, so->bufSize, //Byte array to store received data, offset into the buffer to start sotring the data, number of bytes to receive,
SocketFlags::None, epSender, //bitwise combination of the SocketFlags values, EndPoint that represents the source of the data.
gcnew AsyncCallback(this, &DibbaReaders::ReceiveCallback), so); //AsyncCallback delegate, object containing state information for this request
ReTries = 0;
}
catch (Exception ^)
{
}
}
}
}
Transmit Packet From Server Socket
IPAddress ^address;
int byteId;
array<Byte>^sendBytes = gcnew array<Byte>(1500);
try
{
if (!IPAddress::TryParse(DestIpAddressString, address))
{
//Invalid IP Address
return;
}
byteId = 0;
sendBytes[byteId++] = ;
...
sendBytes[byteId++] = ;
//Transmit Packet
IPEndPoint ^Remote = gcnew IPEndPoint(address, REMOTE_UDP_SOCKET);
serverSocket->SendTo(sendBytes, byteId, System::Net::Sockets::SocketFlags::None, Remote);
}
catch (Exception ^)
{
}
Transmit Packet From Server Socket With Packet Sent Callback
IPAddress ^address;
int byteId;
array<Byte>^sendBytes = gcnew array<Byte>(1500);
try
{
if (!IPAddress::TryParse(DestIpAddressString, address))
{
//Invalid IP Address
return;
}
byteId = 0;
sendBytes[byteId++] = ;
...
sendBytes[byteId++] = ;
//Transmit Packet
IPEndPoint ^Remote = gcnew IPEndPoint(address, REMOTE_UDP_SOCKET);
serverSocket->BeginSendTo(sendBytes, 0, byteId, System::Net::Sockets::SocketFlags::None, Remote, gcnew AsyncCallback(this, &myClassName::OurSendCallback), serverSocket);
while (WaitingTxToComplete)
Threading::Thread::Sleep(20); //(Needed or deployment release version running from .exe will crash)
}
catch (Exception ^)
{
}
//*************************************
//*************************************
//********** UDP TX CALLBACK **********
//*************************************
//*************************************
void myClassName::OurSendCallback(IAsyncResult^ asyncResult)
{
serverSocket->EndSend(asyncResult);
WaitingTxToComplete = false;
}
USEFUL?
We benefit hugely from resources on the web so we decided we should try and give back some of our knowledge and resources to the community by opening up many of our company’s internal notes and libraries through mini sites like this. We hope you find the site helpful.
Please feel free to comment if you can add help to this page or point out issues and solutions you have found, but please note that we do not provide support on this site. If you need help with a problem please use one of the many online forums.