A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
flame-protocol.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2009 IITP RAS
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Kirill Andreev <andreev@iitp.ru>
19  */
20 
21 #include "flame-protocol.h"
22 #include "flame-protocol-mac.h"
23 #include "flame-header.h"
24 #include "flame-rtable.h"
25 #include "ns3/llc-snap-header.h"
26 #include "ns3/log.h"
27 #include "ns3/simulator.h"
28 #include "ns3/packet.h"
29 #include "ns3/mesh-point-device.h"
30 #include "ns3/wifi-net-device.h"
31 #include "ns3/mesh-point-device.h"
32 #include "ns3/mesh-wifi-interface-mac.h"
33 
34 NS_LOG_COMPONENT_DEFINE ("FlameProtocol");
35 
36 namespace ns3 {
37 namespace flame {
38 //-----------------------------------------------------------------------------
39 // FlameTag
40 //-----------------------------------------------------------------------------
41 NS_OBJECT_ENSURE_REGISTERED (FlameTag);
42 NS_OBJECT_ENSURE_REGISTERED (FlameProtocol);
43 
44 TypeId
45 FlameTag::GetTypeId ()
46 {
47  static TypeId tid = TypeId ("ns3::flame::FlameTag").SetParent<Tag> ().AddConstructor<FlameTag> ();
48  return tid;
49 }
50 
51 TypeId
52 FlameTag::GetInstanceTypeId () const
53 {
54  return GetTypeId ();
55 }
56 
57 uint32_t
58 FlameTag::GetSerializedSize () const
59 {
60  return 12;
61 }
62 
63 void
64 FlameTag::Serialize (TagBuffer i) const
65 {
66  uint8_t buf[6];
67  receiver.CopyTo (buf);
68  for (int j = 0; j < 6; j++)
69  {
70  i.WriteU8 (buf[j]);
71  }
72  transmitter.CopyTo (buf);
73  for (int j = 0; j < 6; j++)
74  {
75  i.WriteU8 (buf[j]);
76  }
77 
78 }
79 
80 void
81 FlameTag::Deserialize (TagBuffer i)
82 {
83  uint8_t buf[6];
84  for (int j = 0; j < 6; j++)
85  {
86  buf[j] = i.ReadU8 ();
87  }
88  receiver.CopyFrom (buf);
89  for (int j = 0; j < 6; j++)
90  {
91  buf[j] = i.ReadU8 ();
92  }
93  transmitter.CopyFrom (buf);
94 
95 }
96 
97 void
98 FlameTag::Print (std::ostream &os) const
99 {
100  os << "receiver = " << receiver << ", transmitter = " << transmitter;
101 }
102 
103 //-----------------------------------------------------------------------------
104 // FlameProtocol
105 //-----------------------------------------------------------------------------
106 TypeId
107 FlameProtocol::GetTypeId ()
108 {
109  static TypeId tid = TypeId ("ns3::flame::FlameProtocol")
110  .SetParent<MeshL2RoutingProtocol> ()
111  .AddConstructor<FlameProtocol> ()
112  .AddAttribute ( "BroadcastInterval",
113  "How often we must send broadcast packets",
114  TimeValue (Seconds (5)),
115  MakeTimeAccessor (
116  &FlameProtocol::m_broadcastInterval),
117  MakeTimeChecker ()
118  )
119  .AddAttribute ( "MaxCost",
120  "Cost threshold after which packet will be dropped",
121  UintegerValue (32),
122  MakeUintegerAccessor (
123  &FlameProtocol::m_maxCost),
124  MakeUintegerChecker<uint8_t> (3)
125  )
126  ;
127  return tid;
128 }
129 FlameProtocol::FlameProtocol () :
130  m_address (Mac48Address ()), m_broadcastInterval (Seconds (5)), m_lastBroadcast (Seconds (0)),
131  m_maxCost (32), m_myLastSeqno (1), m_rtable (CreateObject<FlameRtable> ())
132 {
133 }
134 FlameProtocol::~FlameProtocol ()
135 {
136 }
137 void
138 FlameProtocol::DoDispose ()
139 {
140  m_interfaces.clear ();
141  m_rtable = 0;
142  m_mp = 0;
143 }
144 bool
145 FlameProtocol::RequestRoute (uint32_t sourceIface, const Mac48Address source, const Mac48Address destination,
146  Ptr<const Packet> const_packet, uint16_t protocolType, RouteReplyCallback routeReply)
147 {
148  Ptr<Packet> packet = const_packet->Copy ();
149  if (sourceIface == m_mp->GetIfIndex ())
150  {
151  //Packet from upper layer!
152  FlameTag tag;
153  if (packet->PeekPacketTag (tag))
154  {
155  NS_FATAL_ERROR ("FLAME tag is not supposed to be received from upper layers");
156  }
157  FlameRtable::LookupResult result = m_rtable->Lookup (destination);
158  if (result.retransmitter == Mac48Address::GetBroadcast ())
159  {
160  m_lastBroadcast = Simulator::Now ();
161  }
162  if (m_lastBroadcast + m_broadcastInterval < Simulator::Now ())
163  {
164  result.retransmitter = Mac48Address::GetBroadcast ();
165  result.ifIndex = FlameRtable::INTERFACE_ANY;
166  m_lastBroadcast = Simulator::Now ();
167  }
168  FlameHeader flameHdr;
169  flameHdr.AddCost (0);
170  flameHdr.SetSeqno (m_myLastSeqno++);
171  flameHdr.SetProtocol (protocolType);
172  flameHdr.SetOrigDst (destination);
173  flameHdr.SetOrigSrc (source);
174  m_stats.txBytes += packet->GetSize ();
175  packet->AddHeader (flameHdr);
176  tag.receiver = result.retransmitter;
177  if (result.retransmitter == Mac48Address::GetBroadcast ())
178  {
179  m_stats.txBroadcast++;
180  }
181  else
182  {
183  m_stats.txUnicast++;
184  }
185  NS_LOG_DEBUG ("Source: send packet with RA = " << tag.receiver);
186  packet->AddPacketTag (tag);
187  routeReply (true, packet, source, destination, FLAME_PROTOCOL, result.ifIndex);
188  }
189  else
190  {
191  FlameHeader flameHdr;
192  packet->RemoveHeader (flameHdr);
193  FlameTag tag;
194 
195  if (!packet->RemovePacketTag (tag))
196  {
197  NS_FATAL_ERROR ("FLAME tag must exist here");
198  }
199  if (destination == Mac48Address::GetBroadcast ())
200  {
201  //Broadcast always is forwarded as broadcast!
202  NS_ASSERT (HandleDataFrame (flameHdr.GetSeqno (), source, flameHdr, tag.transmitter, sourceIface));
203  FlameTag tag (Mac48Address::GetBroadcast ());
204  flameHdr.AddCost (1);
205  m_stats.txBytes += packet->GetSize ();
206  packet->AddHeader (flameHdr);
207  packet->AddPacketTag (tag);
208  routeReply (true, packet, source, destination, FLAME_PROTOCOL, FlameRtable::INTERFACE_ANY);
209  m_stats.txBroadcast++;
210  return true;
211  }
212  else
213  {
214  // We check sequence only when forward unicast, because broadcast-checks were done
215  // inside remove routing stuff.
216  if (HandleDataFrame (flameHdr.GetSeqno (), source, flameHdr, tag.transmitter, sourceIface))
217  {
218  return false;
219  }
220  FlameRtable::LookupResult result = m_rtable->Lookup (destination);
221  if (tag.receiver != Mac48Address::GetBroadcast ())
222  {
223  if (result.retransmitter == Mac48Address::GetBroadcast ())
224  {
225  NS_LOG_DEBUG ("unicast packet dropped, because no route! I am " << GetAddress ()
226  << ", RA = " << tag.receiver << ", TA = " << tag.transmitter);
227  m_stats.totalDropped++;
228  return false;
229  }
230  tag.receiver = result.retransmitter;
231  }
232  else
233  {
234  tag.receiver = Mac48Address::GetBroadcast ();
235  }
236  if (result.retransmitter == Mac48Address::GetBroadcast ())
237  {
238  m_stats.txBroadcast++;
239  }
240  else
241  {
242  m_stats.txUnicast++;
243  }
244  m_stats.txBytes += packet->GetSize ();
245  flameHdr.AddCost (1);
246  packet->AddHeader (flameHdr);
247  packet->AddPacketTag (tag);
248  routeReply (true, packet, source, destination, FLAME_PROTOCOL, result.ifIndex);
249  return true;
250  }
251  return true;
252  }
253  return false;
254 }
255 bool
256 FlameProtocol::RemoveRoutingStuff (uint32_t fromIface, const Mac48Address source,
257  const Mac48Address destination, Ptr<Packet> packet, uint16_t& protocolType)
258 {
259  //Filter seqno:
260  if (source == GetAddress ())
261  {
262  NS_LOG_DEBUG ("Dropped my own frame!");
263  return false;
264  }
265  FlameTag tag;
266  if (!packet->RemovePacketTag (tag))
267  {
268  NS_FATAL_ERROR ("FLAME tag must exist when packet is coming to protocol");
269  }
270  FlameHeader flameHdr;
271  packet->RemoveHeader (flameHdr);
272  if (HandleDataFrame (flameHdr.GetSeqno (), source, flameHdr, tag.transmitter, fromIface))
273  {
274  return false;
275  }
276  // Start PATH_UPDATE procedure if destination is our own address and last broadcast was sent more
277  // than broadcast interval ago or was not sent at all
278  if ((destination == GetAddress ()) && ((m_lastBroadcast + m_broadcastInterval < Simulator::Now ())
279  || (m_lastBroadcast == Seconds (0))))
280  {
281  Ptr<Packet> packet = Create<Packet> ();
282  m_mp->Send (packet, Mac48Address::GetBroadcast (), 0);
283  m_lastBroadcast = Simulator::Now ();
284  }
285  NS_ASSERT (protocolType == FLAME_PROTOCOL);
286  protocolType = flameHdr.GetProtocol ();
287  return true;
288 }
289 bool
290 FlameProtocol::Install (Ptr<MeshPointDevice> mp)
291 {
292  m_mp = mp;
293  std::vector<Ptr<NetDevice> > interfaces = mp->GetInterfaces ();
294  for (std::vector<Ptr<NetDevice> >::const_iterator i = interfaces.begin (); i != interfaces.end (); i++)
295  {
296  // Checking for compatible net device
297  Ptr<WifiNetDevice> wifiNetDev = (*i)->GetObject<WifiNetDevice> ();
298  if (wifiNetDev == 0)
299  {
300  return false;
301  }
302  Ptr<MeshWifiInterfaceMac> mac = wifiNetDev->GetMac ()->GetObject<MeshWifiInterfaceMac> ();
303  if (mac == 0)
304  {
305  return false;
306  }
307  // Installing plugins:
308  Ptr<FlameProtocolMac> flameMac = Create<FlameProtocolMac> (wifiNetDev->GetIfIndex (), this);
309  m_interfaces[wifiNetDev->GetIfIndex ()] = flameMac;
310  mac->SetBeaconGeneration (false);
311  mac->InstallPlugin (flameMac);
312  }
313  mp->SetRoutingProtocol (this);
314  // Mesh point aggregates all installed protocols
315  mp->AggregateObject (this);
316  m_address = Mac48Address::ConvertFrom (mp->GetAddress ()); //* address;
317  return true;
318 }
319 Mac48Address
320 FlameProtocol::GetAddress ()
321 {
322  return m_address;
323 }
324 bool
325 FlameProtocol::HandleDataFrame (uint16_t seqno, Mac48Address source, const FlameHeader flameHdr,
326  Mac48Address receiver, uint32_t fromInterface)
327 {
328  if (source == GetAddress ())
329  {
330  m_stats.totalDropped++;
331  return true;
332  }
333  FlameRtable::LookupResult result = m_rtable->Lookup (source);
334  if ((result.retransmitter != Mac48Address::GetBroadcast ()) && ((int16_t)(result.seqnum - seqno) >= 0))
335  {
336  return true;
337  }
338  if (flameHdr.GetCost () > m_maxCost)
339  {
340  m_stats.droppedTtl++;
341  return true;
342  }
343  m_rtable->AddPath (source, receiver, fromInterface, flameHdr.GetCost (), flameHdr.GetSeqno ());
344  return false;
345 }
346 //Statistics:
347 FlameProtocol::Statistics::Statistics () :
348  txUnicast (0), txBroadcast (0), txBytes (0), droppedTtl (0), totalDropped (0)
349 {
350 }
351 void
352 FlameProtocol::Statistics::Print (std::ostream & os) const
353 {
354  os << "<Statistics "
355  "txUnicast=\"" << txUnicast << "\" "
356  "txBroadcast=\"" << txBroadcast << "\" "
357  "txBytes=\"" << txBytes << "\" "
358  "droppedTtl=\"" << droppedTtl << "\" "
359  "totalDropped=\"" << totalDropped << "\"/>" << std::endl;
360 }
361 void
362 FlameProtocol::Report (std::ostream & os) const
363 {
364  os << "<Flame "
365  "address=\"" << m_address << "\"" << std::endl <<
366  "broadcastInterval=\"" << m_broadcastInterval.GetSeconds () << "\"" << std::endl <<
367  "maxCost=\"" << (uint16_t) m_maxCost << "\">" << std::endl;
368  m_stats.Print (os);
369  for (FlamePluginMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin++)
370  {
371  plugin->second->Report (os);
372  }
373  os << "</Flame>" << std::endl;
374 }
375 void
376 FlameProtocol::ResetStats ()
377 {
378  m_stats = Statistics ();
379  for (FlamePluginMap::const_iterator plugin = m_interfaces.begin (); plugin != m_interfaces.end (); plugin++)
380  {
381  plugin->second->ResetStats ();
382  }
383 }
384 
385 } // namespace flame
386 } // namespace ns3