Multicast Application with Multihomed Support (C# .NET Sample)

In the previous post we’ve reviewed the multicast addressing technology and examined some of its pitfalls.

In this post we’ll dive through the implementation of a simple application that allows sending and receiving multicast data over the LAN, while enabling the selection of the network interfaces (IPEndPoint) through which the multicast traffic will be sent and received.

As illustrated in the previous post, setting the network interface is crucial when the host is connected to two or more networks or have two or more network cards installed and enabled.

The application source code can be downloaded from here.

 

Configuration

The MulticastConfiguration class encapsulates the configuration entered by the user. It exposes two factory methods that allow instantiating the class for single network hosts and for multi network hosts. The 1st factory method requires only the multicast address/port of the sender and  the receiver, while the 2nd factory method also requires the unicast address of the network card of the sender and  the receiver.

Code Snippet

1.     class MulticastConfiguration
2.     {
3.         readonly IPAddress m_SendMulticastAddress;
4.         readonly int m_SendPort;
5.         readonly int m_ReceivePort;
6.         readonly IPAddress m_ReceiveMulticastAddress;
8.         // Multihomed Support
9.         readonly IPAddress m_SendNetworkCardAddress = IPAddress.Any;
10.         readonly int m_SendNetworkCardPort;
11.         readonly IPAddress m_ReceiveNetworkCardAddress = IPAddress.Any;
13.         public MulticastConfiguration(
14.             IPAddress sendMulticastAddress,
15.             int sendPort,
16.             IPAddress receiveMulticastAddress,
17.             int receivePort)
18.         {
19.             m_SendMulticastAddress = sendMulticastAddress;
20.             m_SendPort = sendPort;
21.             m_ReceiveMulticastAddress = receiveMulticastAddress;
22.             m_ReceivePort = receivePort;
23.         }
25.         public MulticastConfiguration(
26.             IPAddress sendMulticastAddress,
27.             int sendPort,
28.             IPAddress receiveMulticastAddress,
29.             int receivePort,
30.             IPAddress sendExplicitSourceAddressm,
31.             int sendExplicitSourcePort,
32.             IPAddress receiveExplicitSourceAddress)
33.             : this(
34.             sendMulticastAddress,
35.             sendPort,
36.             receiveMulticastAddress,
37.             receivePort)
38.         {
39.             m_SendNetworkCardAddress = sendExplicitSourceAddressm;
40.             m_SendNetworkCardPort = sendExplicitSourcePort;
41.             m_ReceiveNetworkCardAddress = receiveExplicitSourceAddress;
42.         }
44.         public static MulticastConfiguration CreateForSingleInterfaceNetwork(
45.             IPAddress sendMulticastAddress,
46.             int sendPort,
47.             IPAddress receiveMulticastAddress,
48.             int receivePort)
49.         {
50.             return new MulticastConfiguration(
51.                 sendMulticastAddress,
52.                 sendPort,
53.                 receiveMulticastAddress,
54.                 receivePort);
55.         }
57.         public static MulticastConfiguration CreateForMultiHomedNetwork(
58.             IPAddress sendMulticastAddress,
59.             int sendPort,
60.             IPAddress receiveMulticastAddress,
61.             int receivePort,
62.             IPAddress sendExplicitSourceAddressm,
63.             int sendExplicitSourcePort,
64.             IPAddress receiveExplicitSourceAddress)
65.         {
66.             return new MulticastConfiguration(
67.                 sendMulticastAddress,
68.                 sendPort,
69.                 receiveMulticastAddress,
70.                 receivePort,
71.                 sendExplicitSourceAddressm,
72.                 sendExplicitSourcePort,
73.                 receiveExplicitSourceAddress);
74.         }
76.         public IPAddress SendMulticastAddress
77.         {
78.             get { return m_SendMulticastAddress; }
79.         }
81.         public int SendPort
82.         {
83.             get { return m_SendPort; }
84.         }
86.         public IPAddress ReceiveMulticastAddress
87.         {
88.             get { return m_ReceiveMulticastAddress; }
89.         }
91.         public int ReceivePort
92.         {
93.             get { return m_ReceivePort; }
94.         }
96.         public IPAddress SendNetworkCardAddress
97.         {
98.             get { return m_SendNetworkCardAddress; }
99.         }
101.         public int SendNetworkCardPort
102.         {
103.             get { return m_SendNetworkCardPort; }
104.         }
106.         public IPAddress ReceiveNetworkCardAddress
107.         {
108.             get { return m_ReceiveNetworkCardAddress; }
109.         }
110.     }

Transport

The TransportAgent class is in charge of creating the sockets that receive and send the data, joining to the multicast group (i.e. sending IGMP package to the router) and binding both sockets to the appropriate network interface.

Code Snippet

1.     class TransportAgent
2.     {
3.         static readonly IPEndPoint AnyAddress = new IPEndPoint(IPAddress.Any, 0);
4.         private readonly byte[] m_objectStateBuffer = new byte[8192];
6.         private readonly MulticastConfiguration m_dataEntity;
8.         private readonly Socket m_sendSocket;
9.         private readonly Socket m_receiveSocket;
10.         private  bool m_opened;
12.         public TransportAgent(
13.             MulticastConfiguration entity,
14.             EventHandler<BufferReceivedEventArgs> messageReceived)
15.             : this(entity)
16.         {
17.             MessageReceived += messageReceived;
18.         }
20.         public TransportAgent(MulticastConfiguration entity)
21.         {
22.             m_dataEntity = entity;
23.            
24.             m_sendSocket = CreateUdpSocket();
26.             EndPoint sendEndPoint = new IPEndPoint(
27.                 m_dataEntity.SendNetworkCardAddress,
28.                 m_dataEntity.SendNetworkCardPort);
29.            
30.             // define the address of the network card from
31.             // which the multicast data will be sent. 
32.             m_sendSocket.Bind(sendEndPoint);
34.             m_receiveSocket = CreateUdpSocket();
35.            
36.             EndPoint receiveEndPoint = new IPEndPoint(
37.                 m_dataEntity.ReceiveNetworkCardAddress,
38.                 m_dataEntity.ReceivePort);
40.             // define the address of the network card from
41.             // which the multicast data will be received. 
42.             m_receiveSocket.Bind(receiveEndPoint);
43.            
44.             // Send the IGMP message to the router, ask to
45.             // goin to the multicast group
46.             JoinMulticast(m_receiveSocket);
48.             BeginReceive();
50.             m_opened = true;
51.         }
53.         public event EventHandler<BufferReceivedEventArgs> MessageReceived = delegate { };
55.         public void Close()
56.         {
57.             if (!m_opened)
58.             {
59.                 return;
60.             }
62.             DropMulticast(m_receiveSocket);
63.             m_receiveSocket.Close();
64.             m_sendSocket.Close();
66.             m_opened = false;
67.         }
69.         public void Send(byte[] message)
70.         {
71.             StateObject stateObject = new StateObject(
72.                 m_sendSocket, message);
74.             IPEndPoint endPoint = new IPEndPoint(
75.                 m_dataEntity.SendMulticastAddress,
76.                 m_dataEntity.SendPort);
78.             int offset = 0;
79.            
80.             m_sendSocket.BeginSendTo(
81.                 message,
82.                 offset,
83.                 message.Length,
84.                 SocketFlags.None,
85.                 endPoint,
86.                 OnSend,
87.                 stateObject);           
88.         }
90.         private void OnSend(IAsyncResult ar)
91.         {
92.             int bytesCount = m_sendSocket.EndSendTo(ar);
94.             Trace.WriteLine(
95.                 string.Format("Messages Sent, Bytes: {0}",
96.                 bytesCount));
97.         }
99.         private void BeginReceive()
100.         {
101.             Socket receiveSocket = m_receiveSocket;
102.             if (receiveSocket == null) return;
103.         
104.             EndPoint remoteEP = AnyAddress;
106.             StateObject stateObject = new StateObject(
107.                 receiveSocket, m_objectStateBuffer);
109.             int offset = 0;
111.             receiveSocket.BeginReceiveFrom(
112.                 stateObject.Buffer,
113.                 offset,
114.                 stateObject.Buffer.Length,
115.                 SocketFlags.None,
116.                 ref remoteEP,
117.                 OnReceive,
118.                 stateObject);
119.         }
121.         private void OnReceive(IAsyncResult result)
122.         {
123.             EndPoint remoteEP = AnyAddress;
124.             try
125.             {
126.                 int bufferSize = m_receiveSocket.EndReceiveFrom(
127.                     result, ref remoteEP);
129.                 StateObject stateObject =
130.                     (StateObject)result.AsyncState;
131.                
132.                 BufferReceivedEventArgs e = new BufferReceivedEventArgs(
133.                     stateObject.Buffer, bufferSize);
134.                
135.                 MessageReceived(this, e);
136.                
137.                 BeginReceive();
138.             }
139.             catch
140.             {
141.                 Trace.WriteLine("Disconnection");
142.             }
144.         }
146.         private static Socket CreateUdpSocket()
147.         {
148.             Socket socket = new Socket(
149.                 AddressFamily.InterNetwork,
150.                 SocketType.Dgram,
151.                 ProtocolType.Udp);
152.            
153.             return socket;
155.         }
157.         private void JoinMulticast(Socket socket)
158.         {
159.             MulticastOption multicastOption = GetMulticastOption();
160.            
161.             socket.SetSocketOption(
162.                 SocketOptionLevel.IP,
163.                 SocketOptionName.MulticastTimeToLive,
164.                 64);
165.            
166.             socket.SetSocketOption(
167.                 SocketOptionLevel.IP,
168.                 SocketOptionName.AddMembership,
169.                 multicastOption);
171.         }
173.         private void DropMulticast(Socket socket)
174.         {
175.             MulticastOption multicastOption = GetMulticastOption();
176.            
177.             socket.SetSocketOption(
178.                 SocketOptionLevel.IP,
179.                 SocketOptionName.MulticastTimeToLive,
180.                 64);
181.            
182.             socket.SetSocketOption(
183.                 SocketOptionLevel.IP,
184.                 SocketOptionName.DropMembership,
185.                 multicastOption);
186.         }
188.         private MulticastOption GetMulticastOption()
189.         {
190.             IPAddress ip = m_dataEntity.ReceiveMulticastAddress;
192.             // MulticastOption can be constructed with the
193.             // overload that allows setting the address of
194.             // the network card from which the IGMP package
195.             // will be sent to the router.
196.             MulticastOption mo = new MulticastOption(ip);
197.             return mo;
198.         }
199.     }

Host

All the host has to do is to read the configuration from the UI, instantiate the configuration class, and instantiate the transport class - injecting it with the configuration instance and with delegate to OnMessageReceived callback that will be called when ever data arrive.

Code Snippet

2.     MulticastConfiguration multicastConfiguration = ReadConfiguration();
4.     m_TransportAgent = new TransportAgent(
5.         multicastConfiguration, OnMessageReceived);

Sending Multicast Data

Code Snippet

2.     ASCIIEncoding asciiEncoding = new ASCIIEncoding();
3.     string message = m_textBoxMessage.Text;
4.     byte[] bytes = asciiEncoding.GetBytes(message);
6.     m_TransportAgent.Send(bytes);

Receiving Multicast Data

Code Snippet

1.     private void OnMessageReceived(object sender, BufferReceivedEventArgs e)
2.     {
3.         string message = Encoding.ASCII.GetString(e.Buffer);
4.         Print(message);
5.     }

Debugging

My choice for network protocol analyzer is Wireshark which is the best analyzer available today, it’s released under the GNU General Public License (GPL) so it can be used freely.

To get started, download the source code and run the multicast tester application, download Wireshark, run it and start a capture session,

IGMP

In order to get a feeling about the way that multicast addressing works – let’s review the IGMP message that is sent to the router when the receiver socket joins to the multicast group (see TransportAgent line 166).

Enter ‘igmp’ in Wireshark filter.

In  the multicast tester application, press ‘Connect’. The ‘network card interface’ in the receiver configuration is set to my local machine upper network card address.

As a result, IGMP package was sent to the network, requesting it to add network interface with address 192.168.2.100 (which is my upper network card address) to the multicast group 224.0.0.12. Consequently, the network will deliver any multicast data sent to group 224.0.0.12 to address 192.168.2.100.

Now, In the multicast tester application, press ‘disconnect’.

As a result, IGMP package was sent to the network, requesting it to remove the network interface from the group.

Sending Multicast Data – Single Network

Enter ‘udp’ in Wireshark filter.

In  the multicast tester application, leave the ‘Network Card Address’ and ‘Network Card Port’ in the sender configuration blank, press ‘Connect’, enter some string to the message text box and press ‘Send’

As a result, the string that was specified (in this case ‘aviad’) is sent form the network card 192.168.2.100, port 3704. Since we didn’t specify the network card address and port – the operation system took the liberty to select network card and port.

Sending Multicast Data – Multihomed Network

In  the multicast tester application, set the sender ‘Network Card Address’ to one of your network cards address and set the ‘Network Card Port’ to 1234, press ‘Connect’, enter some string to the message text box and press ‘Send’.

As a result, the string is sent form the network card 192.168.2.100, port 1234. Since we did specify the network card address and port – the network card and the port from which the string was sent were NOT the selection of the operation system. Even though in the previous case the operation system selected the same network card that we specified, in cases where there are more than 1 enabled and active network cards in the machine - you must specify the appropriate network address or your multicast may be delivered though the wrong network.