From aac765a2b17d83f4a3ccd73a1b91106bf249ee1c Mon Sep 17 00:00:00 2001
From: Andrey Mazo <mazo@iitp.ru>
Date: Fri, 13 Mar 2009 21:09:40 +0300
Subject: [PATCH] Coding style changes: indentation, spaces.

---
 examples/mesh.cc                              |  141 +-
 examples/routing-table-test.cc                |  284 ++--
 .../l2-routing/l2-routing-hwmp/hwmp-rtable.cc |  344 ++--
 .../l2-routing/l2-routing-hwmp/hwmp-rtable.h  |  147 +-
 .../l2-routing/l2-routing-hwmp/hwmp-state.cc  |  762 ++++-----
 .../l2-routing/l2-routing-hwmp/hwmp-state.h   |  309 ++--
 .../l2-routing/l2-routing-hwmp/hwmp.cc        |  959 ++++++------
 src/devices/l2-routing/l2-routing-hwmp/hwmp.h |  507 +++---
 .../l2-routing-main/l2-routing-net-device.cc  |  346 ++--
 .../l2-routing-main/l2-routing-net-device.h   |  259 ++-
 src/devices/mesh/mesh.h                       |   12 +-
 src/devices/wifi/dot11s-codes.h               |  104 +-
 src/devices/wifi/dot11s-parameters.cc         |    5 +-
 src/devices/wifi/dot11s-parameters.h          |   39 +-
 .../wifi/dot11s-peer-management-element.cc    |  110 +-
 .../wifi/dot11s-peer-management-element.h     |   71 +-
 .../wifi/mesh-configuration-element.cc        |  189 ++-
 src/devices/wifi/mesh-configuration-element.h |   77 +-
 src/devices/wifi/mesh-mgt-headers.cc          |  214 +--
 src/devices/wifi/mesh-mgt-headers.h           |  112 +-
 .../wifi/mesh-wifi-beacon-timing-element.cc   |  186 +--
 .../wifi/mesh-wifi-beacon-timing-element.h    |  145 +-
 src/devices/wifi/mesh-wifi-mac-header.cc      |  390 ++---
 src/devices/wifi/mesh-wifi-mac-header.h       |  204 +--
 src/devices/wifi/mesh-wifi-mac.cc             | 1328 ++++++++--------
 src/devices/wifi/mesh-wifi-mac.h              |  671 ++++----
 src/devices/wifi/mesh-wifi-peer-manager.cc    | 1389 +++++++++--------
 src/devices/wifi/mesh-wifi-peer-manager.h     |  571 ++++---
 .../mesh-wifi-perr-information-element.cc     |  128 +-
 .../wifi/mesh-wifi-perr-information-element.h |   69 +-
 .../mesh-wifi-prep-information-element.cc     |  210 +--
 .../wifi/mesh-wifi-prep-information-element.h |   99 +-
 .../mesh-wifi-preq-information-element.cc     |  412 ++---
 .../wifi/mesh-wifi-preq-information-element.h |  176 +--
 .../mesh-wifi-rann-information-element.cc     |  124 +-
 .../wifi/mesh-wifi-rann-information-element.h |   81 +-
 src/devices/wifi/tx-statistics.cc             |  151 +-
 src/devices/wifi/tx-statistics.h              |  122 +-
 src/helper/hwmp-helper.cc                     |    2 +-
 src/helper/hwmp-helper.h                      |    2 +-
 src/helper/mesh-wifi-helper.cc                |  279 ++--
 src/helper/mesh-wifi-helper.h                 |  173 +-
 src/node/l2-routing-protocol.cc               |    8 +-
 src/node/l2-routing-protocol.h                |  223 ++-
 src/node/mac48-address-comparator.h           |   26 +-
 45 files changed, 6064 insertions(+), 6096 deletions(-)

diff --git a/examples/mesh.cc b/examples/mesh.cc
index 2a43fc787..1a167e4c4 100644
--- a/examples/mesh.cc
+++ b/examples/mesh.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -34,75 +34,74 @@ NS_LOG_COMPONENT_DEFINE ("TestMeshScript");
 int
 main(int argc, char *argv[])
 {
-	// Creating square topology with nNodes x nNodes grid:
-	int			xSize		=	5;
-	int         ySize       =   5;
-	double			step		=	100.0;	//Grid with one-hop edge
-	double			randomStart	=	0.1;	//One beacon interval
-	NodeContainer		nodes;
-	CommandLine		cmd;
-	MobilityHelper		mobility;
-	MeshWifiHelper		wifi;
-	NetDeviceContainer	meshDevices;
-	// Defining a size of our network:
-	cmd.AddValue("x-size", "Number of nodes in a row grid", xSize);
-	cmd.AddValue("y-size", "Number of rows in a grid", ySize);
-	cmd.AddValue("step", "Size of edge in our grid", step);
-	cmd.AddValue("start", "Random start parameter", randomStart);
-        cmd.Parse (argc, argv);
-	NS_LOG_DEBUG("Grid:"<<xSize<<"*"<<ySize);
-	// Creating nodes:
-	nodes.Create (ySize*xSize);
+  // Creating square topology with nNodes x nNodes grid:
+  int      xSize       = 5;
+  int      ySize       = 5;
+  double   step        = 100.0; //Grid with one-hop edge
+  double   randomStart = 0.1; //One beacon interval
+  NodeContainer      nodes;
+  CommandLine        cmd;
+  MobilityHelper     mobility;
+  MeshWifiHelper     wifi;
+  NetDeviceContainer meshDevices;
+  // Defining a size of our network:
+  cmd.AddValue("x-size", "Number of nodes in a row grid", xSize);
+  cmd.AddValue("y-size", "Number of rows in a grid", ySize);
+  cmd.AddValue("step", "Size of edge in our grid", step);
+  cmd.AddValue("start", "Random start parameter", randomStart);
+  cmd.Parse (argc, argv);
+  NS_LOG_DEBUG("Grid:"<<xSize<<"*"<<ySize);
+  // Creating nodes:
+  nodes.Create (ySize*xSize);
 
-	// Setting channel:
-	YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
-	YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
-	wifiPhy.SetChannel (wifiChannel.Create ());
-	// Setting Wifi:
-	//wifi.SetPhy("ns3::WifiPhy");
-	wifi.SetRemoteStationManager("ns3::AarfWifiManager");
-	Ssid ssid	=	Ssid("MyMeSH");
-	wifi.SetMac ("ns3::MeshWifiMac",
-			"Ssid", SsidValue (ssid),
-			"RandomStart", TimeValue (Seconds (randomStart))
-			);
-        wifi.SetPeerLinkManager ("ns3::WifiPeerManager");
-        wifi.SetL2RoutingProtocol ("ns3::Hwmp");
-        wifi.SetL2RoutingNetDevice ("ns3::L2RoutingNetDevice");
-	meshDevices	=	wifi.Install (wifiPhy,nodes,1);
-	// Installing Mobility.
-	mobility.SetPositionAllocator
-		("ns3::GridPositionAllocator",
-		 "MinX", DoubleValue (0.0),
-		 "MinY", DoubleValue (0.0),
-		 "DeltaX", DoubleValue (step),
-                 "DeltaY", DoubleValue (step),
-		 "GridWidth", UintegerValue (xSize),
-		 "LayoutType", StringValue("RowFirst"));
-	NS_LOG_UNCOND("Mobility");
-	mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
-	mobility.Install (nodes);
-	NS_LOG_UNCOND("Mobility installed");
-	// Setting Internet Stack:
-	InternetStackHelper stack;
-	stack.Install(nodes);
-	Ipv4AddressHelper address;
-	address.SetBase ("10.1.1.0", "255.255.255.0");
-	Ipv4InterfaceContainer interfaces = address.Assign (meshDevices);
-	UdpEchoServerHelper echoServer (9);
-	ApplicationContainer serverApps = echoServer.Install (nodes.Get (0));
-	serverApps.Start (Seconds (1.0));
-	serverApps.Stop (Seconds (10.0));
-	UdpEchoClientHelper echoClient (interfaces.GetAddress (0), 9);
-	echoClient.SetAttribute ("MaxPackets", UintegerValue (1000));
-	echoClient.SetAttribute ("Interval", TimeValue (Seconds (0.001)));
-	echoClient.SetAttribute ("PacketSize", UintegerValue (1024));
-	ApplicationContainer clientApps = echoClient.Install (nodes.Get (1));
-	clientApps.Start (Seconds (2.0));
-	clientApps.Stop (Seconds (10.0));
-	//end
-	Simulator::Stop (Seconds (10.0));
-	Simulator::Run();
-	Simulator::Destroy();
-	return 0;
+  // Setting channel:
+  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();
+  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();
+  wifiPhy.SetChannel (wifiChannel.Create ());
+  // Setting Wifi:
+  //wifi.SetPhy("ns3::WifiPhy");
+  wifi.SetRemoteStationManager("ns3::AarfWifiManager");
+  Ssid ssid = Ssid("MyMeSH");
+  wifi.SetMac ("ns3::MeshWifiMac",
+               "Ssid", SsidValue (ssid),
+               "RandomStart", TimeValue (Seconds (randomStart))
+              );
+  wifi.SetPeerLinkManager ("ns3::WifiPeerManager");
+  wifi.SetL2RoutingProtocol ("ns3::Hwmp");
+  wifi.SetL2RoutingNetDevice ("ns3::L2RoutingNetDevice");
+  meshDevices = wifi.Install (wifiPhy,nodes,1);
+  // Installing Mobility.
+  mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
+                                 "MinX", DoubleValue (0.0),
+                                 "MinY", DoubleValue (0.0),
+                                 "DeltaX", DoubleValue (step),
+                                 "DeltaY", DoubleValue (step),
+                                 "GridWidth", UintegerValue (xSize),
+                                 "LayoutType", StringValue("RowFirst"));
+  NS_LOG_UNCOND("Mobility");
+  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
+  mobility.Install (nodes);
+  NS_LOG_UNCOND("Mobility installed");
+  // Setting Internet Stack:
+  InternetStackHelper stack;
+  stack.Install(nodes);
+  Ipv4AddressHelper address;
+  address.SetBase ("10.1.1.0", "255.255.255.0");
+  Ipv4InterfaceContainer interfaces = address.Assign (meshDevices);
+  UdpEchoServerHelper echoServer (9);
+  ApplicationContainer serverApps = echoServer.Install (nodes.Get (0));
+  serverApps.Start (Seconds (1.0));
+  serverApps.Stop (Seconds (10.0));
+  UdpEchoClientHelper echoClient (interfaces.GetAddress (0), 9);
+  echoClient.SetAttribute ("MaxPackets", UintegerValue (1000));
+  echoClient.SetAttribute ("Interval", TimeValue (Seconds (0.001)));
+  echoClient.SetAttribute ("PacketSize", UintegerValue (1024));
+  ApplicationContainer clientApps = echoClient.Install (nodes.Get (1));
+  clientApps.Start (Seconds (2.0));
+  clientApps.Stop (Seconds (10.0));
+  //end
+  Simulator::Stop (Seconds (10.0));
+  Simulator::Run();
+  Simulator::Destroy();
+  return 0;
 }
diff --git a/examples/routing-table-test.cc b/examples/routing-table-test.cc
index 4fc29ecc3..5640b4e5c 100644
--- a/examples/routing-table-test.cc
+++ b/examples/routing-table-test.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -38,167 +38,171 @@ NS_LOG_COMPONENT_DEFINE("RoutingTableTest");
 void
 aux_function(Ptr<HwmpRtable> ptr,Mac48Address addr,std::vector<bool> *results, std::vector<Time> *seconds)
 {
-	if (ptr->LookupReactive(addr).retransmitter.IsBroadcast() && ptr->LookupReactive(addr).metric == 0xffffffff)
-	results->push_back(false);
-	else results->push_back(true);
-	seconds->push_back(Simulator::Now());
-	NS_LOG_UNCOND("Reactive retransmitter is "<<ptr->LookupReactive(addr).retransmitter << "\nport is "<<ptr->LookupReactive(addr).ifIndex << "\nmetric is " << ptr->LookupReactive(addr).metric << "\nseqnum is " << ptr->LookupReactive(addr).seqnum);
-	NS_LOG_UNCOND("Checked at "<<Simulator::Now().GetSeconds()<<" seconds\n\n");
+  if (ptr->LookupReactive(addr).retransmitter.IsBroadcast() && ptr->LookupReactive(addr).metric == 0xffffffff)
+    results->push_back(false);
+  else
+    results->push_back(true);
+
+  seconds->push_back(Simulator::Now());
+  NS_LOG_UNCOND("Reactive retransmitter is "<<ptr->LookupReactive(addr).retransmitter << "\nport is "<<ptr->LookupReactive(addr).ifIndex << "\nmetric is " << ptr->LookupReactive(addr).metric << "\nseqnum is " << ptr->LookupReactive(addr).seqnum);
+  NS_LOG_UNCOND("Checked at "<<Simulator::Now().GetSeconds()<<" seconds\n\n");
 };
 
 
 void
 aux_function1(Ptr<HwmpRtable> ptr,uint32_t port,std::vector<bool> *results,std::vector<Time> *seconds)
 {
-	if (ptr->LookupProactive(port).retransmitter.IsBroadcast() && ptr->LookupProactive(port).metric == 0xffffffff)
-	results->push_back(false);
-	else results->push_back(true);
-	seconds->push_back(Simulator::Now());
-	NS_LOG_UNCOND("Proactive retransmitter is "<<ptr->LookupProactive(port).retransmitter<< "\nport is "<<ptr->LookupProactive(port).ifIndex << "\nmetric is " << ptr->LookupProactive(port).metric << "\nseqnum is " << ptr->LookupProactive(port).seqnum);
-	NS_LOG_UNCOND("Checked at "<<Simulator::Now().GetSeconds()<<" seconds\n\n");
+  if (ptr->LookupProactive(port).retransmitter.IsBroadcast() && ptr->LookupProactive(port).metric == 0xffffffff)
+    results->push_back(false);
+  else
+    results->push_back(true);
+
+  seconds->push_back(Simulator::Now());
+  NS_LOG_UNCOND("Proactive retransmitter is "<<ptr->LookupProactive(port).retransmitter<< "\nport is "<<ptr->LookupProactive(port).ifIndex << "\nmetric is " << ptr->LookupProactive(port).metric << "\nseqnum is " << ptr->LookupProactive(port).seqnum);
+  NS_LOG_UNCOND("Checked at "<<Simulator::Now().GetSeconds()<<" seconds\n\n");
 };
 
 void
 print_results(std::vector<bool> *results,std::vector<Time> *seconds)
 {
-NS_LOG_UNCOND("Fulfilled "<<results->size()<<" tests\n");
-for (unsigned int i = 0;i!=results->size();i++)
-	{
-	NS_LOG_UNCOND("Result: "<<results->at(i));
-	NS_LOG_UNCOND("Tested at "<<seconds->at(i).GetSeconds()<<" seconds\n");
-	}
+  NS_LOG_UNCOND("Fulfilled "<<results->size()<<" tests\n");
+  for (unsigned int i = 0;i!=results->size();i++)
+    {
+      NS_LOG_UNCOND("Result: "<<results->at(i));
+      NS_LOG_UNCOND("Tested at "<<seconds->at(i).GetSeconds()<<" seconds\n");
+    }
 }
 
-void 
+void
 get_conclusion(std::vector<bool> *results)
 {
-	if (
-		results->at(0) 
-		&& results->at(1) 
-		&& results->at(2)
-		&& results->at(3)
-		&& results->at(4)
-		&& results->at(5)
-		&& results->at(6)
-		&& results->at(7)
-		&& !results->at(8)
-		&& !results->at(9)
-		&& !results->at(10)
-		&& !results->at(11)
-		&& !results->at(12)
-		&& !results->at(13)
-		&& !results->at(14))
-		NS_LOG_UNCOND("\n\n\nPASSED\n\n\n");
-	else		
-		NS_LOG_UNCOND("\n\n\nNOT PASSED\n\n\n");
+  if (
+    results->at(0)
+    && results->at(1)
+    && results->at(2)
+    && results->at(3)
+    && results->at(4)
+    && results->at(5)
+    && results->at(6)
+    && results->at(7)
+    && !results->at(8)
+    && !results->at(9)
+    && !results->at(10)
+    && !results->at(11)
+    && !results->at(12)
+    && !results->at(13)
+    && !results->at(14))
+    NS_LOG_UNCOND("\n\n\nPASSED\n\n\n");
+  else
+    NS_LOG_UNCOND("\n\n\nNOT PASSED\n\n\n");
 
 }
 
 int main(int argc,char *argv[])
-{	
-	// Create Table
-	Ptr<HwmpRtable> table = CreateObject<HwmpRtable>();
-	std::vector<bool>  test_results = std::vector<bool>();
-	std::vector<Time>  test_time = std::vector<Time>();
-	//Add reactive paths
-	table->AddReactivePath(Mac48Address("01:00:00:01:00:01"),Mac48Address("01:00:00:01:00:03"),8010,10,Seconds(20),1);
-	table->AddReactivePath(Mac48Address("01:00:00:02:00:01"),Mac48Address("01:00:00:02:00:03"),8020,20,Seconds(30),2);
-//	table->AddReactivePath(Mac48Address("01:00:00:03:00:01"),Mac48Address("01:00:00:03:00:03"),8030,30,Seconds(30),3);
-//	table->AddReactivePath(Mac48Address("01:00:00:04:00:01"),Mac48Address("01:00:00:04:00:03"),8040,40,Seconds(35),4);
-	//Add proactive paths
-	table->AddProactivePath(10,Mac48Address("01:00:00:01:00:01"),Mac48Address("01:00:00:01:00:03"),8010,Seconds(20),1);
-	table->AddProactivePath(20,Mac48Address("01:00:00:02:00:01"),Mac48Address("01:00:00:02:00:03"),8020,Seconds(30),2);
-	table->AddProactivePath(30,Mac48Address("01:00:00:03:00:01"),Mac48Address("01:00:00:03:00:03"),8030,Seconds(20),3);
-	table->AddProactivePath(40,Mac48Address("01:00:00:04:00:01"),Mac48Address("01:00:00:04:00:03"),8040,Seconds(30),4);
-	Simulator::Schedule(Seconds(0.0),
-			    &aux_function,
-			    table,
-			    Mac48Address("01:00:00:01:00:01"),&test_results,&test_time);
-	Simulator::Schedule(Seconds(0.0),
-			    &aux_function1,
-			    table,
-			    8010,&test_results,&test_time);
-	Simulator::Schedule(Seconds(0.0),
-			    &aux_function,
-			    table,
-			    Mac48Address("01:00:00:02:00:01"),&test_results,&test_time);
-	Simulator::Schedule(Seconds(0.0),
-			    &aux_function1,
-			    table,
-			    8020,&test_results,&test_time);
-	Simulator::Schedule(Seconds(1.0),
-			    &aux_function,
-			    table,
-			    Mac48Address("01:00:00:01:00:01"),&test_results,&test_time);
-	Simulator::Schedule(Seconds(1.0),
-			    &aux_function1,
-			    table,
-			    8010,&test_results,&test_time);
-	Simulator::Schedule(Seconds(1.0),
-			    &aux_function,
-			    table,
-			    Mac48Address("01:00:00:02:00:01"),&test_results,&test_time);
-	Simulator::Schedule(Seconds(1.0),
-			    &aux_function1,
-			    table,
-			    8020,&test_results,&test_time);
-	//Print routing info
-	NS_LOG_UNCOND("Added reactive path number "<<table->LookupReactive(Mac48Address("01:00:00:01:00:01")).seqnum << " at dest " << table->LookupReactive(Mac48Address("01:00:00:01:00:01")).retransmitter << " with metric "<< table->LookupReactive(Mac48Address("01:00:00:01:00:01")).metric <<"\n");
-	NS_LOG_UNCOND("Added reactive path number "<<table->LookupReactive(Mac48Address("01:00:00:02:00:01")).seqnum << " at dest " << table->LookupReactive(Mac48Address("01:00:00:02:00:01")).retransmitter << " with metric "<< table->LookupReactive(Mac48Address("01:00:00:02:00:01")).metric <<"\n");
-	NS_LOG_UNCOND("Added reactive path number "<<table->LookupReactive(Mac48Address("01:00:00:03:00:01")).seqnum << " at dest " << table->LookupReactive(Mac48Address("01:00:00:03:00:01")).retransmitter << " with metric "<< table->LookupReactive(Mac48Address("01:00:00:03:00:01")).metric <<"\n");
-	NS_LOG_UNCOND("Added reactive path number "<<table->LookupReactive(Mac48Address("01:00:00:04:00:01")).seqnum << " at dest " << table->LookupReactive(Mac48Address("01:00:00:04:00:01")).retransmitter << " with metric "<< table->LookupReactive(Mac48Address("01:00:00:04:00:01")).metric <<"\n");
+{
+  // Create Table
+  Ptr<HwmpRtable> table = CreateObject<HwmpRtable>();
+  std::vector<bool>  test_results = std::vector<bool>();
+  std::vector<Time>  test_time = std::vector<Time>();
+  //Add reactive paths
+  table->AddReactivePath(Mac48Address("01:00:00:01:00:01"),Mac48Address("01:00:00:01:00:03"),8010,10,Seconds(20),1);
+  table->AddReactivePath(Mac48Address("01:00:00:02:00:01"),Mac48Address("01:00:00:02:00:03"),8020,20,Seconds(30),2);
+// table->AddReactivePath(Mac48Address("01:00:00:03:00:01"),Mac48Address("01:00:00:03:00:03"),8030,30,Seconds(30),3);
+// table->AddReactivePath(Mac48Address("01:00:00:04:00:01"),Mac48Address("01:00:00:04:00:03"),8040,40,Seconds(35),4);
+  //Add proactive paths
+  table->AddProactivePath(10,Mac48Address("01:00:00:01:00:01"),Mac48Address("01:00:00:01:00:03"),8010,Seconds(20),1);
+  table->AddProactivePath(20,Mac48Address("01:00:00:02:00:01"),Mac48Address("01:00:00:02:00:03"),8020,Seconds(30),2);
+  table->AddProactivePath(30,Mac48Address("01:00:00:03:00:01"),Mac48Address("01:00:00:03:00:03"),8030,Seconds(20),3);
+  table->AddProactivePath(40,Mac48Address("01:00:00:04:00:01"),Mac48Address("01:00:00:04:00:03"),8040,Seconds(30),4);
+  Simulator::Schedule(Seconds(0.0),
+                      &aux_function,
+                      table,
+                      Mac48Address("01:00:00:01:00:01"),&test_results,&test_time);
+  Simulator::Schedule(Seconds(0.0),
+                      &aux_function1,
+                      table,
+                      8010,&test_results,&test_time);
+  Simulator::Schedule(Seconds(0.0),
+                      &aux_function,
+                      table,
+                      Mac48Address("01:00:00:02:00:01"),&test_results,&test_time);
+  Simulator::Schedule(Seconds(0.0),
+                      &aux_function1,
+                      table,
+                      8020,&test_results,&test_time);
+  Simulator::Schedule(Seconds(1.0),
+                      &aux_function,
+                      table,
+                      Mac48Address("01:00:00:01:00:01"),&test_results,&test_time);
+  Simulator::Schedule(Seconds(1.0),
+                      &aux_function1,
+                      table,
+                      8010,&test_results,&test_time);
+  Simulator::Schedule(Seconds(1.0),
+                      &aux_function,
+                      table,
+                      Mac48Address("01:00:00:02:00:01"),&test_results,&test_time);
+  Simulator::Schedule(Seconds(1.0),
+                      &aux_function1,
+                      table,
+                      8020,&test_results,&test_time);
+  //Print routing info
+  NS_LOG_UNCOND("Added reactive path number "<<table->LookupReactive(Mac48Address("01:00:00:01:00:01")).seqnum << " at dest " << table->LookupReactive(Mac48Address("01:00:00:01:00:01")).retransmitter << " with metric "<< table->LookupReactive(Mac48Address("01:00:00:01:00:01")).metric <<"\n");
+  NS_LOG_UNCOND("Added reactive path number "<<table->LookupReactive(Mac48Address("01:00:00:02:00:01")).seqnum << " at dest " << table->LookupReactive(Mac48Address("01:00:00:02:00:01")).retransmitter << " with metric "<< table->LookupReactive(Mac48Address("01:00:00:02:00:01")).metric <<"\n");
+  NS_LOG_UNCOND("Added reactive path number "<<table->LookupReactive(Mac48Address("01:00:00:03:00:01")).seqnum << " at dest " << table->LookupReactive(Mac48Address("01:00:00:03:00:01")).retransmitter << " with metric "<< table->LookupReactive(Mac48Address("01:00:00:03:00:01")).metric <<"\n");
+  NS_LOG_UNCOND("Added reactive path number "<<table->LookupReactive(Mac48Address("01:00:00:04:00:01")).seqnum << " at dest " << table->LookupReactive(Mac48Address("01:00:00:04:00:01")).retransmitter << " with metric "<< table->LookupReactive(Mac48Address("01:00:00:04:00:01")).metric <<"\n");
 
-	NS_LOG_UNCOND("Added proactive path number " << table->LookupProactive(8010).seqnum <<" with retr "<< table->LookupProactive(8010).retransmitter<< " at port " <<table->LookupProactive(8010).ifIndex<< " with metric " <<table->LookupProactive(8010).metric<<"\n");
-	NS_LOG_UNCOND("Added proactive path number " << table->LookupProactive(8020).seqnum <<" with retr "<< table->LookupProactive(8020).retransmitter<< " at port " <<table->LookupProactive(8020).ifIndex<< " with metric " <<table->LookupProactive(8020).metric<<"\n");
-	NS_LOG_UNCOND("Added proactive path number " << table->LookupProactive(8030).seqnum <<" with retr "<< table->LookupProactive(8030).retransmitter<< " at port " <<table->LookupProactive(8030).ifIndex<< " with metric " <<table->LookupProactive(8030).metric<<"\n");
-	NS_LOG_UNCOND("Added proactive path number " << table->LookupProactive(8040).seqnum <<" with retr "<< table->LookupProactive(8040).retransmitter<< " at port " <<table->LookupProactive(8040).ifIndex<< " with metric " <<table->LookupProactive(8040).metric<<"\n");
+  NS_LOG_UNCOND("Added proactive path number " << table->LookupProactive(8010).seqnum <<" with retr "<< table->LookupProactive(8010).retransmitter<< " at port " <<table->LookupProactive(8010).ifIndex<< " with metric " <<table->LookupProactive(8010).metric<<"\n");
+  NS_LOG_UNCOND("Added proactive path number " << table->LookupProactive(8020).seqnum <<" with retr "<< table->LookupProactive(8020).retransmitter<< " at port " <<table->LookupProactive(8020).ifIndex<< " with metric " <<table->LookupProactive(8020).metric<<"\n");
+  NS_LOG_UNCOND("Added proactive path number " << table->LookupProactive(8030).seqnum <<" with retr "<< table->LookupProactive(8030).retransmitter<< " at port " <<table->LookupProactive(8030).ifIndex<< " with metric " <<table->LookupProactive(8030).metric<<"\n");
+  NS_LOG_UNCOND("Added proactive path number " << table->LookupProactive(8040).seqnum <<" with retr "<< table->LookupProactive(8040).retransmitter<< " at port " <<table->LookupProactive(8040).ifIndex<< " with metric " <<table->LookupProactive(8040).metric<<"\n");
 
-	table->DeleteProactivePath(8030);
-	table->DeleteProactivePath(Mac48Address("01:00:00:04:00:01"),8040);
-	Simulator::Schedule(Seconds(1.0),
-			    &aux_function1,
-			    table,
-			    8030,&test_results,&test_time);
-	Simulator::Schedule(Seconds(1.0),
-			    &aux_function1,
-			    table,
-			    8040,&test_results,&test_time);
+  table->DeleteProactivePath(8030);
+  table->DeleteProactivePath(Mac48Address("01:00:00:04:00:01"),8040);
+  Simulator::Schedule(Seconds(1.0),
+                      &aux_function1,
+                      table,
+                      8030,&test_results,&test_time);
+  Simulator::Schedule(Seconds(1.0),
+                      &aux_function1,
+                      table,
+                      8040,&test_results,&test_time);
 
-	Simulator::Schedule(Seconds(10.0),
-			    &HwmpRtable::DeleteReactivePath,
-			    table,
-			    Mac48Address("01:00:00:02:00:01"),8020);
+  Simulator::Schedule(Seconds(10.0),
+                      &HwmpRtable::DeleteReactivePath,
+                      table,
+                      Mac48Address("01:00:00:02:00:01"),8020);
 
-	Simulator::Schedule(Seconds(15.0),
-			    &aux_function,
-			    table,
-			    Mac48Address("01:00:00:02:00:01"),&test_results,&test_time);
-        Simulator::Schedule(Seconds(25.0),
-			    &aux_function,
-			    table,
-			    Mac48Address("01:00:00:01:00:01"),&test_results,&test_time);
-	Simulator::Schedule(Seconds(25.0),
-			    &aux_function,
-			    table,
-			    Mac48Address("01:00:00:02:00:01"),&test_results,&test_time);
-	Simulator::Schedule(Seconds(25.0),
-			    &aux_function1,
-			    table,
-			    8010,&test_results,&test_time);
-	Simulator::Schedule(Seconds(30.0),
-			    &aux_function,
-			    table,
-			    Mac48Address("01:00:00:01:00:01"),&test_results,&test_time);
-	
-	Simulator::Schedule(Seconds(40.0),
-			    &print_results,
-                            &test_results,&test_time);
-	Simulator::Schedule(Seconds(41.0),
-			    &get_conclusion,
-		            &test_results);
-	
-	Simulator::Run();
-	Simulator::Destroy();
-	return 0;
+  Simulator::Schedule(Seconds(15.0),
+                      &aux_function,
+                      table,
+                      Mac48Address("01:00:00:02:00:01"),&test_results,&test_time);
+  Simulator::Schedule(Seconds(25.0),
+                      &aux_function,
+                      table,
+                      Mac48Address("01:00:00:01:00:01"),&test_results,&test_time);
+  Simulator::Schedule(Seconds(25.0),
+                      &aux_function,
+                      table,
+                      Mac48Address("01:00:00:02:00:01"),&test_results,&test_time);
+  Simulator::Schedule(Seconds(25.0),
+                      &aux_function1,
+                      table,
+                      8010,&test_results,&test_time);
+  Simulator::Schedule(Seconds(30.0),
+                      &aux_function,
+                      table,
+                      Mac48Address("01:00:00:01:00:01"),&test_results,&test_time);
+
+  Simulator::Schedule(Seconds(40.0),
+                      &print_results,
+                      &test_results,&test_time);
+  Simulator::Schedule(Seconds(41.0),
+                      &get_conclusion,
+                      &test_results);
+
+  Simulator::Run();
+  Simulator::Destroy();
+  return 0;
 }
 
diff --git a/src/devices/l2-routing/l2-routing-hwmp/hwmp-rtable.cc b/src/devices/l2-routing/l2-routing-hwmp/hwmp-rtable.cc
index 942538f59..0217c13ed 100644
--- a/src/devices/l2-routing/l2-routing-hwmp/hwmp-rtable.cc
+++ b/src/devices/l2-routing/l2-routing-hwmp/hwmp-rtable.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -36,10 +36,10 @@ NS_OBJECT_ENSURE_REGISTERED (HwmpRtable);
 TypeId
 HwmpRtable::GetTypeId()
 {
-	static TypeId tid = TypeId ("ns3::HwmpRtable")
-		.SetParent<Object> ()
-		.AddConstructor<HwmpRtable> ();
-	return tid;
+  static TypeId tid = TypeId ("ns3::HwmpRtable")
+                      .SetParent<Object> ()
+                      .AddConstructor<HwmpRtable> ();
+  return tid;
 
 }
 
@@ -49,234 +49,234 @@ HwmpRtable::HwmpRtable()
 
 HwmpRtable::~HwmpRtable()
 {
-	DoDispose();
+  DoDispose();
 }
 
 void
 HwmpRtable::DoDispose()
 {
-	NS_LOG_UNCOND("RTABLE DISPOSE STARTED");
-	m_routes.clear();
-	m_roots.clear();
+  NS_LOG_UNCOND("RTABLE DISPOSE STARTED");
+  m_routes.clear();
+  m_roots.clear();
 }
 
 void
 HwmpRtable::AddReactivePath(
-		Mac48Address	destination,
-		Mac48Address	retransmitter,
-		uint32_t	port,
-		uint32_t	metric,
-		Time		lifetime,
-		uint32_t	seqnum
-		)
+  Mac48Address destination,
+  Mac48Address retransmitter,
+  uint32_t port,
+  uint32_t metric,
+  Time  lifetime,
+  uint32_t seqnum
+)
 {
-	std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
-	if(i == m_routes.end())
-	{
-		ReactiveRoute newroute;
-		m_routes[destination] = newroute;
-	}
-	else
-	{
-		/**
-		 * if outport differs from stored, routing info is
-		 * actual and metric is worse - we ignore this
-		 * information
-		 */
-		if(
-				(i->second.port != port) &&
-				(i->second.metric < metric) &&
-				/**
-				 * The routing info is actual or it
-				 * was received from peer
-				 */
-				((i->second.whenExpire > Simulator::Now())||(i->second.whenExpire == Seconds(0)))
-				)
-			return;
-	}
-	i = m_routes.find(destination);
-	NS_ASSERT(i != m_routes.end());
-	i->second.retransmitter = retransmitter;
-	i->second.port = port;
-	i->second.metric = metric;
-	if(lifetime != Seconds(0))
-		i->second.whenExpire = MilliSeconds(Simulator::Now().GetMilliSeconds() + lifetime.GetMilliSeconds());
-	else
-		/**
-		 * Information about peer does not have lifetime
-		 */
-		i->second.whenExpire = Seconds(0);
-	i->second.seqnum = seqnum;
+  std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
+  if (i == m_routes.end())
+    {
+      ReactiveRoute newroute;
+      m_routes[destination] = newroute;
+    }
+  else
+    {
+      /**
+       * if outport differs from stored, routing info is
+       * actual and metric is worse - we ignore this
+       * information
+       */
+      if (
+        (i->second.port != port) &&
+        (i->second.metric < metric) &&
+        /**
+         * The routing info is actual or it
+         * was received from peer
+         */
+        ((i->second.whenExpire > Simulator::Now())||(i->second.whenExpire == Seconds(0)))
+      )
+        return;
+    }
+  i = m_routes.find(destination);
+  NS_ASSERT(i != m_routes.end());
+  i->second.retransmitter = retransmitter;
+  i->second.port = port;
+  i->second.metric = metric;
+  if (lifetime != Seconds(0))
+    i->second.whenExpire = MilliSeconds(Simulator::Now().GetMilliSeconds() + lifetime.GetMilliSeconds());
+  else
+    /**
+     * Information about peer does not have lifetime
+     */
+    i->second.whenExpire = Seconds(0);
+  i->second.seqnum = seqnum;
 }
 
 void
 HwmpRtable::AddProactivePath(
-		uint32_t	metric,
-		Mac48Address	root,
-		Mac48Address	retransmitter,
-		uint32_t	port,
-		Time		lifetime,
-		uint32_t	seqnum
-		)
+  uint32_t metric,
+  Mac48Address root,
+  Mac48Address retransmitter,
+  uint32_t port,
+  Time  lifetime,
+  uint32_t seqnum
+)
 {
-	ProactiveRoute newroute;
-	m_roots[port] = newroute;
-	std::map<uint32_t,ProactiveRoute>::iterator i = m_roots.find(port);
-	NS_ASSERT(i != m_roots.end());
-	i->second.root = root;
-	i->second.retransmitter = retransmitter;
-	i->second.metric = metric;
-	i->second.whenExpire = MilliSeconds(Simulator::Now().GetMilliSeconds() + lifetime.GetMilliSeconds());
-	i->second.seqnum = seqnum;
+  ProactiveRoute newroute;
+  m_roots[port] = newroute;
+  std::map<uint32_t,ProactiveRoute>::iterator i = m_roots.find(port);
+  NS_ASSERT(i != m_roots.end());
+  i->second.root = root;
+  i->second.retransmitter = retransmitter;
+  i->second.metric = metric;
+  i->second.whenExpire = MilliSeconds(Simulator::Now().GetMilliSeconds() + lifetime.GetMilliSeconds());
+  i->second.seqnum = seqnum;
 
 }
 
 void
 HwmpRtable::AddPrecursor(Mac48Address destination, uint32_t port, Mac48Address precursor)
 {
-	bool should_add = true;
-	std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
-	if((i != m_routes.end()) && (i->second.port == port))
-	{
-		for(unsigned int j = 0 ; j < i->second.precursors.size(); j ++)
-			if(i->second.precursors[j] == precursor)
-			{
-				should_add = false;
-				break;
-			}
-		if(should_add)
-			i->second.precursors.push_back(precursor);
-	}
-	std::map<uint32_t,ProactiveRoute>::iterator k = m_roots.find(port);
-	if(k!= m_roots.end())
-	{
-		for(unsigned int j = 0 ; j < k->second.precursors.size(); j ++)
-			if(k->second.precursors[j] == precursor)
-				return;
-		k->second.precursors.push_back(precursor);
-		return;
-	}
+  bool should_add = true;
+  std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
+  if ((i != m_routes.end()) && (i->second.port == port))
+    {
+      for (unsigned int j = 0 ; j < i->second.precursors.size(); j ++)
+        if (i->second.precursors[j] == precursor)
+          {
+            should_add = false;
+            break;
+          }
+      if (should_add)
+        i->second.precursors.push_back(precursor);
+    }
+  std::map<uint32_t,ProactiveRoute>::iterator k = m_roots.find(port);
+  if (k!= m_roots.end())
+    {
+      for (unsigned int j = 0 ; j < k->second.precursors.size(); j ++)
+        if (k->second.precursors[j] == precursor)
+          return;
+      k->second.precursors.push_back(precursor);
+      return;
+    }
 }
 
 void
 HwmpRtable::DeleteProactivePath(uint32_t port)
 {
-	std::map<uint32_t,ProactiveRoute>::iterator j = m_roots.find(port);
-	if(j != m_roots.end())
-		m_roots.erase(j);
+  std::map<uint32_t,ProactiveRoute>::iterator j = m_roots.find(port);
+  if (j != m_roots.end())
+    m_roots.erase(j);
 
 }
 void
 HwmpRtable::DeleteProactivePath(Mac48Address root, uint32_t port)
 {
-	std::map<uint32_t,ProactiveRoute>::iterator j = m_roots.find(port);
-	if((j != m_roots.end())&&(j->second.root == root))
-		m_roots.erase(j);
+  std::map<uint32_t,ProactiveRoute>::iterator j = m_roots.find(port);
+  if ((j != m_roots.end())&&(j->second.root == root))
+    m_roots.erase(j);
 
 }
 
 void
 HwmpRtable::DeleteReactivePath(Mac48Address destination, uint32_t port)
 {
-	std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
-	if(i != m_routes.end())
-		if(i->second.port ==  port)
-			m_routes.erase(i);
+  std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
+  if (i != m_routes.end())
+    if (i->second.port ==  port)
+      m_routes.erase(i);
 }
 
 HwmpRtable::LookupResult
 HwmpRtable::LookupReactive(Mac48Address destination)
 {
-	LookupResult result;
-	result.retransmitter = Mac48Address::GetBroadcast();
-	result.metric = MAX_METRIC;
-	result.ifIndex = PORT_ANY;
-	
-	std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
-	if(i == m_routes.end())
-		return result;
-	result.ifIndex = i->second.port;
-	//Seconds(0) means that this is routing
-	if(i->second.whenExpire < Simulator::Now())
-		if(i->second.retransmitter != destination)
-			return result;
-	result.retransmitter = i->second.retransmitter;
-	result.metric = i->second.metric;
-	result.seqnum = i->second.seqnum;
-	return result;
+  LookupResult result;
+  result.retransmitter = Mac48Address::GetBroadcast();
+  result.metric = MAX_METRIC;
+  result.ifIndex = PORT_ANY;
+
+  std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
+  if (i == m_routes.end())
+    return result;
+  result.ifIndex = i->second.port;
+  //Seconds(0) means that this is routing
+  if (i->second.whenExpire < Simulator::Now())
+    if (i->second.retransmitter != destination)
+      return result;
+  result.retransmitter = i->second.retransmitter;
+  result.metric = i->second.metric;
+  result.seqnum = i->second.seqnum;
+  return result;
 }
 
 HwmpRtable::LookupResult
 HwmpRtable::LookupProactive(uint32_t port)
 {
-	LookupResult result;
-	result.retransmitter = Mac48Address::GetBroadcast();
-	result.metric = MAX_METRIC;
-	result.ifIndex = PORT_ANY;
-	std::map<uint32_t, ProactiveRoute, mac48addrComparator>::iterator i = m_roots.find(port);
-	if(i == m_roots.end())
-		return result;
-	result.ifIndex = i->first;
-	if(i->second.whenExpire < Simulator::Now())
-		return result;
-	result.retransmitter = i->second.retransmitter;
-	result.metric = i->second.metric;
-	result.seqnum = i->second.seqnum;
-	return result;
+  LookupResult result;
+  result.retransmitter = Mac48Address::GetBroadcast();
+  result.metric = MAX_METRIC;
+  result.ifIndex = PORT_ANY;
+  std::map<uint32_t, ProactiveRoute, mac48addrComparator>::iterator i = m_roots.find(port);
+  if (i == m_roots.end())
+    return result;
+  result.ifIndex = i->first;
+  if (i->second.whenExpire < Simulator::Now())
+    return result;
+  result.retransmitter = i->second.retransmitter;
+  result.metric = i->second.metric;
+  result.seqnum = i->second.seqnum;
+  return result;
 }
 
 std::vector<HwmpRtable::FailedDestination>
 HwmpRtable::GetUnreachableDestinations(Mac48Address peerAddress, uint32_t port)
 {
-	std::vector<FailedDestination> retval;
-	for(std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.begin(); i!= m_routes.end(); i++)
-		if((i->second.retransmitter == peerAddress)&&(i->second.port == port))
-		{
-			FailedDestination dst;
-			dst.destination = i->first;
-			i->second.seqnum ++;
-			dst.seqnum = i->second.seqnum;
-			retval.push_back(dst);
-		}
-	/**
-	 * Lookup a path to root
-	 */
-	std::map<uint32_t, ProactiveRoute, mac48addrComparator>::iterator i = m_roots.find(port);
-	if((i != m_roots.end())&&(i->second.retransmitter == peerAddress))
-	{
-		FailedDestination dst;
-		dst.destination = i->second.root;
-		dst.seqnum = i->second.seqnum;
-		retval.push_back(dst);
-	}
-	return retval;
+  std::vector<FailedDestination> retval;
+  for (std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.begin(); i!= m_routes.end(); i++)
+    if ((i->second.retransmitter == peerAddress)&&(i->second.port == port))
+      {
+        FailedDestination dst;
+        dst.destination = i->first;
+        i->second.seqnum ++;
+        dst.seqnum = i->second.seqnum;
+        retval.push_back(dst);
+      }
+  /**
+   * Lookup a path to root
+   */
+  std::map<uint32_t, ProactiveRoute, mac48addrComparator>::iterator i = m_roots.find(port);
+  if ((i != m_roots.end())&&(i->second.retransmitter == peerAddress))
+    {
+      FailedDestination dst;
+      dst.destination = i->second.root;
+      dst.seqnum = i->second.seqnum;
+      retval.push_back(dst);
+    }
+  return retval;
 }
 uint32_t
 HwmpRtable::RequestSeqnum(Mac48Address destination)
 {
-	std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
-	if(i == m_routes.end())
-		return 0;
-	return i->second.seqnum;
+  std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator i = m_routes.find(destination);
+  if (i == m_routes.end())
+    return 0;
+  return i->second.seqnum;
 }
 
 std::vector<Mac48Address>
 HwmpRtable::GetPrecursors(Mac48Address destination, uint32_t port)
 {
-	std::vector<Mac48Address> retval;
-	std::map<uint32_t, ProactiveRoute, mac48addrComparator>::iterator root = m_roots.find(port);
-	if((root != m_roots.end()) &&(root->second.root == destination))
-	{
-		for(unsigned int i = 0; i < root->second.precursors.size(); i ++)
-			retval.push_back(root->second.precursors[i]);
-	}
-	std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator route = m_routes.find(destination);
-	if( (route != m_routes.end()) && (route->second.port == port) )
-	{
-		for(unsigned int i = 0; i < route->second.precursors.size(); i ++)
-			retval.push_back(route->second.precursors[i]);
-	}
-	return retval;
+  std::vector<Mac48Address> retval;
+  std::map<uint32_t, ProactiveRoute, mac48addrComparator>::iterator root = m_roots.find(port);
+  if ((root != m_roots.end()) &&(root->second.root == destination))
+    {
+      for (unsigned int i = 0; i < root->second.precursors.size(); i ++)
+        retval.push_back(root->second.precursors[i]);
+    }
+  std::map<Mac48Address, ReactiveRoute, mac48addrComparator>::iterator route = m_routes.find(destination);
+  if ( (route != m_routes.end()) && (route->second.port == port) )
+    {
+      for (unsigned int i = 0; i < route->second.precursors.size(); i ++)
+        retval.push_back(route->second.precursors[i]);
+    }
+  return retval;
 }
 
 }//namespace ns3
diff --git a/src/devices/l2-routing/l2-routing-hwmp/hwmp-rtable.h b/src/devices/l2-routing/l2-routing-hwmp/hwmp-rtable.h
index c33c47bff..e23eb9d9d 100644
--- a/src/devices/l2-routing/l2-routing-hwmp/hwmp-rtable.h
+++ b/src/devices/l2-routing/l2-routing-hwmp/hwmp-rtable.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -35,81 +35,74 @@ namespace ns3 {
 /**
  * \ingroup mesh
  */
-	class HwmpRtable : public Object
-	{
-		public:
-			static TypeId	GetTypeId	();
-			HwmpRtable();
-			~HwmpRtable();
-			void	DoDispose();
-			void	AddReactivePath(
-					Mac48Address	destination,
-					Mac48Address	retransmitter,
-					uint32_t	port,
-					uint32_t	metric,
-					Time		lifetime,
-					uint32_t	seqnum
-					);
-			void	AddProactivePath(
-					uint32_t	metric,
-					Mac48Address	root,
-					Mac48Address	retransmitter,
-					uint32_t	port,
-					Time		lifetime,
-					uint32_t	seqnum
-					);
-			void	AddPrecursor(Mac48Address destination, uint32_t port, Mac48Address precursor);
-			void	DeleteProactivePath(uint32_t port);
-			void	DeleteProactivePath(Mac48Address root, uint32_t port);
-			void	DeleteReactivePath(Mac48Address destination, uint32_t port);
-			struct LookupResult
-			{
-				Mac48Address	retransmitter;
-				uint32_t	ifIndex;
-				uint32_t	metric;
-				uint32_t	seqnum;
-			};
-			LookupResult
-				LookupReactive(Mac48Address destination);
-			LookupResult
-				LookupProactive(uint32_t port);
-			//path error routines:
-			struct FailedDestination
-			{
-				Mac48Address	destination;
-				uint32_t	seqnum;
-			};
-			std::vector<FailedDestination>
-				GetUnreachableDestinations(Mac48Address peerAddress, uint32_t port);
-			uint32_t
-				RequestSeqnum(Mac48Address dst);
-			std::vector<Mac48Address>
-				GetPrecursors(Mac48Address destination, uint32_t port);
-			const static uint32_t	PORT_ANY = 0xffffffff;
-			const static uint32_t	MAX_METRIC = 0xffffffff;
-		private:
-			struct ReactiveRoute
-			{
-				Mac48Address retransmitter;
-				uint32_t port;
-				uint32_t metric;
-				Time whenExpire;
-				uint32_t seqnum;
-				std::vector<Mac48Address> precursors;
-			};
-			struct ProactiveRoute
-			{
-				Mac48Address root;
-				Mac48Address retransmitter;
-				uint32_t metric;
-				Time whenExpire;
-				uint32_t seqnum;
-				std::vector<Mac48Address> precursors;
-			};
-			std::map<Mac48Address, ReactiveRoute, mac48addrComparator>
-				m_routes;
-			std::map<uint32_t, ProactiveRoute>
-				m_roots;
-	};
+class HwmpRtable : public Object
+{
+public:
+  static TypeId GetTypeId ();
+  HwmpRtable();
+  ~HwmpRtable();
+  void DoDispose();
+  void AddReactivePath(
+    Mac48Address destination,
+    Mac48Address retransmitter,
+    uint32_t port,
+    uint32_t metric,
+    Time  lifetime,
+    uint32_t seqnum
+  );
+  void AddProactivePath(
+    uint32_t metric,
+    Mac48Address root,
+    Mac48Address retransmitter,
+    uint32_t port,
+    Time  lifetime,
+    uint32_t seqnum
+  );
+  void AddPrecursor(Mac48Address destination, uint32_t port, Mac48Address precursor);
+  void DeleteProactivePath(uint32_t port);
+  void DeleteProactivePath(Mac48Address root, uint32_t port);
+  void DeleteReactivePath(Mac48Address destination, uint32_t port);
+  struct LookupResult
+  {
+    Mac48Address retransmitter;
+    uint32_t ifIndex;
+    uint32_t metric;
+    uint32_t seqnum;
+  };
+  LookupResult  LookupReactive(Mac48Address destination);
+  LookupResult  LookupProactive(uint32_t port);
+  //path error routines:
+  struct FailedDestination
+  {
+    Mac48Address destination;
+    uint32_t seqnum;
+  };
+  std::vector<FailedDestination>  GetUnreachableDestinations(Mac48Address peerAddress, uint32_t port);
+  uint32_t  RequestSeqnum(Mac48Address dst);
+  std::vector<Mac48Address>  GetPrecursors(Mac48Address destination, uint32_t port);
+  const static uint32_t PORT_ANY = 0xffffffff;
+  const static uint32_t MAX_METRIC = 0xffffffff;
+private:
+  struct ReactiveRoute
+  {
+    Mac48Address retransmitter;
+    uint32_t port;
+    uint32_t metric;
+    Time whenExpire;
+    uint32_t seqnum;
+    std::vector<Mac48Address> precursors;
+  };
+  struct ProactiveRoute
+  {
+    Mac48Address root;
+    Mac48Address retransmitter;
+    uint32_t metric;
+    Time whenExpire;
+    uint32_t seqnum;
+    std::vector<Mac48Address> precursors;
+  };
+  std::map<Mac48Address, ReactiveRoute, mac48addrComparator>  m_routes;
+  std::map<uint32_t, ProactiveRoute>  m_roots;
+};
 } //namespace ns3
 #endif
diff --git a/src/devices/l2-routing/l2-routing-hwmp/hwmp-state.cc b/src/devices/l2-routing/l2-routing-hwmp/hwmp-state.cc
index 18293db3c..d6dbbe07e 100644
--- a/src/devices/l2-routing/l2-routing-hwmp/hwmp-state.cc
+++ b/src/devices/l2-routing/l2-routing-hwmp/hwmp-state.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -30,436 +30,436 @@ NS_LOG_COMPONENT_DEFINE ("HwmpState");
 TypeId
 HwmpState::GetTypeId ()
 {
-	static TypeId tid = TypeId ("ns3::HwmpState")
-		.SetParent<Object> ()
-		.AddConstructor<HwmpState> ()
-		;
-	return tid;
+  static TypeId tid = TypeId ("ns3::HwmpState")
+                      .SetParent<Object> ()
+                      .AddConstructor<HwmpState> ()
+                      ;
+  return tid;
 }
 
 HwmpState::HwmpState():
-	m_myPreq(m_preqQueue.end()),
-	m_preqId(1),
-	m_myDsn(1),
-	m_disabled(false),
-	m_maxTtl(10)
+    m_myPreq(m_preqQueue.end()),
+    m_preqId(1),
+    m_myDsn(1),
+    m_disabled(false),
+    m_maxTtl(10)
 {
 }
 void
 HwmpState::SetRequestRouteCallback(
-		Callback<HwmpRtable::LookupResult, const Mac48Address&> cb)
+  Callback<HwmpRtable::LookupResult, const Mac48Address&> cb)
 {
-	m_requestRouteCallback = cb;
+  m_requestRouteCallback = cb;
 }
 
 void
 HwmpState::SetRequestRootPathCallback(
-		Callback<HwmpRtable::LookupResult, uint32_t> cb)
+  Callback<HwmpRtable::LookupResult, uint32_t> cb)
 {
-	m_requestRootPathCallback = cb;
+  m_requestRootPathCallback = cb;
 }
 
 //Setting MAC
 void
 HwmpState::SetMac(Ptr<MeshWifiMac> mac)
 {
-	mac->SetPeerStatusCallback(MakeCallback(&HwmpState::PeerStatus, this));
-	mac->SetPreqReceivedCallback(MakeCallback(&HwmpState::ReceivePreq, this));
-	mac->SetPrepReceivedCallback(MakeCallback(&HwmpState::ReceivePrep, this));
-	mac->SetPerrReceivedCallback(MakeCallback(&HwmpState::ReceivePerr, this));
-	m_address = mac->GetAddress();
-	m_preqCallback = MakeCallback(&MeshWifiMac::SendPreq, mac);
-	m_prepCallback = MakeCallback(&MeshWifiMac::SendPrep, mac);
-	m_perrCallback = MakeCallback(&MeshWifiMac::SendPerr, mac);
+  mac->SetPeerStatusCallback(MakeCallback(&HwmpState::PeerStatus, this));
+  mac->SetPreqReceivedCallback(MakeCallback(&HwmpState::ReceivePreq, this));
+  mac->SetPrepReceivedCallback(MakeCallback(&HwmpState::ReceivePrep, this));
+  mac->SetPerrReceivedCallback(MakeCallback(&HwmpState::ReceivePerr, this));
+  m_address = mac->GetAddress();
+  m_preqCallback = MakeCallback(&MeshWifiMac::SendPreq, mac);
+  m_prepCallback = MakeCallback(&MeshWifiMac::SendPrep, mac);
+  m_perrCallback = MakeCallback(&MeshWifiMac::SendPerr, mac);
 }
 HwmpState::~HwmpState()
 {
-	m_preqQueue.clear();
+  m_preqQueue.clear();
 }
 //Interaction with HWMP:
 void
 HwmpState::SetRoutingInfoCallback(
-		Callback<void, INFO> cb
-		)
+  Callback<void, INFO> cb
+)
 {
-	m_routingInfoCallback = cb;
+  m_routingInfoCallback = cb;
 }
 
 void
 HwmpState::SetRetransmittersOfPerrCallback(
-		Callback<std::vector<Mac48Address>, std::vector<HwmpRtable::FailedDestination>, uint32_t> cb)
+  Callback<std::vector<Mac48Address>, std::vector<HwmpRtable::FailedDestination>, uint32_t> cb)
 {
-	m_retransmittersOfPerrCallback = cb;
+  m_retransmittersOfPerrCallback = cb;
 }
 
 void
 HwmpState::RequestDestination(Mac48Address dst)
 {
-	if(m_preqQueue.end() == m_myPreq)
-	{
-		WifiPreqInformationElement preq;
-		//fill PREQ:
-		preq.SetHopcount(0);
-		preq.SetTTL(m_maxTtl);
-		preq.SetPreqID(m_preqId++);
-		if(m_preqId == MAX_PREQ_ID)
-			m_preqId = 0;
-		preq.SetLifetime(TIME_TO_TU(dot11sParameters::dot11MeshHWMPactivePathTimeout));
-		preq.SetOriginatorSeqNumber(m_myDsn++);
-		if(m_myDsn == MAX_DSN)
-			m_myDsn = 0;
-		preq.SetOriginatorAddress(m_address);
-		preq.AddDestinationAddressElement(false, false, dst, 0); //DO = 0, RF = 0
-		if(m_preqTimer.IsRunning())
-		{
-			NS_LOG_DEBUG("No my preq");
-			m_preqQueue.push_back(preq);
-			//set iterator position to my preq:
-			m_myPreq = m_preqQueue.end() -1;
-		}
-		else
-		{
-			NS_LOG_DEBUG("Send PREQ now, "<<preq.GetPreqID()<<" destinations, now is "<<Simulator::Now());
-			m_preqCallback(preq);
-		NS_ASSERT(!m_preqTimer.IsRunning());
-			m_preqTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPpreqMinInterval, &HwmpState::SendOnePreq, this);
-		}
-	}
-	else
-	{
-		NS_ASSERT(m_myPreq->GetOriginatorAddress() == m_address);
-		NS_LOG_DEBUG("add a destination "<<dst);
-		m_myPreq->AddDestinationAddressElement(false, false, dst, 0); //DO = 0, RF = 0
-	}
+  if (m_preqQueue.end() == m_myPreq)
+    {
+      WifiPreqInformationElement preq;
+      //fill PREQ:
+      preq.SetHopcount(0);
+      preq.SetTTL(m_maxTtl);
+      preq.SetPreqID(m_preqId++);
+      if (m_preqId == MAX_PREQ_ID)
+        m_preqId = 0;
+      preq.SetLifetime(TIME_TO_TU(dot11sParameters::dot11MeshHWMPactivePathTimeout));
+      preq.SetOriginatorSeqNumber(m_myDsn++);
+      if (m_myDsn == MAX_DSN)
+        m_myDsn = 0;
+      preq.SetOriginatorAddress(m_address);
+      preq.AddDestinationAddressElement(false, false, dst, 0); //DO = 0, RF = 0
+      if (m_preqTimer.IsRunning())
+        {
+          NS_LOG_DEBUG("No my preq");
+          m_preqQueue.push_back(preq);
+          //set iterator position to my preq:
+          m_myPreq = m_preqQueue.end() -1;
+        }
+      else
+        {
+          NS_LOG_DEBUG("Send PREQ now, "<<preq.GetPreqID()<<" destinations, now is "<<Simulator::Now());
+          m_preqCallback(preq);
+          NS_ASSERT(!m_preqTimer.IsRunning());
+          m_preqTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPpreqMinInterval, &HwmpState::SendOnePreq, this);
+        }
+    }
+  else
+    {
+      NS_ASSERT(m_myPreq->GetOriginatorAddress() == m_address);
+      NS_LOG_DEBUG("add a destination "<<dst);
+      m_myPreq->AddDestinationAddressElement(false, false, dst, 0); //DO = 0, RF = 0
+    }
 }
 void
 HwmpState::SendPathError(std::vector<HwmpRtable::FailedDestination> destinations)
 {
-	std::vector<Mac48Address> receivers =  m_retransmittersOfPerrCallback(destinations, m_ifIndex);
-	NS_LOG_DEBUG("SendPathError started");
-	if(receivers.size()== 0)
-		return;
-	NS_LOG_DEBUG(m_address<<" Should Send PERR to");
-	for(unsigned int i = 0; i < receivers.size(); i ++)
-	{
-		AddPerrReceiver(receivers[i]);
-		NS_LOG_DEBUG(receivers[i]);
-	}
-	NS_LOG_DEBUG("To tel about failure with");
-	for(unsigned int i = 0; i < destinations.size(); i ++)
-	{
-		m_myPerr.AddAddressUnit(destinations[i]);
-		NS_LOG_DEBUG(destinations[i].destination);
-	}
-	if(!m_perrTimer.IsRunning())
-	{
-		m_perrCallback(m_myPerr,m_myPerrReceivers);
-		m_myPerr.ResetPerr();
-		m_perrTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPperrMinInterval,&HwmpState::SendOnePerr,this);
-	}
+  std::vector<Mac48Address> receivers =  m_retransmittersOfPerrCallback(destinations, m_ifIndex);
+  NS_LOG_DEBUG("SendPathError started");
+  if (receivers.size() == 0)
+    return;
+  NS_LOG_DEBUG(m_address<<" Should Send PERR to");
+  for (unsigned int i = 0; i < receivers.size(); i ++)
+    {
+      AddPerrReceiver(receivers[i]);
+      NS_LOG_DEBUG(receivers[i]);
+    }
+  NS_LOG_DEBUG("To tel about failure with");
+  for (unsigned int i = 0; i < destinations.size(); i ++)
+    {
+      m_myPerr.AddAddressUnit(destinations[i]);
+      NS_LOG_DEBUG(destinations[i].destination);
+    }
+  if (!m_perrTimer.IsRunning())
+    {
+      m_perrCallback(m_myPerr,m_myPerrReceivers);
+      m_myPerr.ResetPerr();
+      m_perrTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPperrMinInterval,&HwmpState::SendOnePerr,this);
+    }
 }
 //needed to fill routing information structure
 void
 HwmpState::SetAssociatedIfaceId(uint32_t interface)
 {
-	m_ifIndex = interface;
+  m_ifIndex = interface;
 }
 
 uint32_t
 HwmpState::GetAssociatedIfaceId()
 {
-	return m_ifIndex;
+  return m_ifIndex;
 }
 
 //Interaction with MAC:
 void
 HwmpState::ReceivePreq(WifiPreqInformationElement& preq,  const Mac48Address& from, const uint32_t& metric)
 {
-	if(m_disabled)
-		return;
-	if(preq.GetOriginatorAddress() == m_address)
-		return;
-	preq.DecrementTtl();
-	preq.IncrementMetric(metric);
-	if(preq.GetTtl() == 0)
-		return;
-	//acceptance cretirea:
-	std::map<Mac48Address, uint32_t, mac48addrComparator>::iterator i = m_dsnDatabase.find(preq.GetOriginatorAddress());
-	if(i == m_dsnDatabase.end())
-	{
-		m_dsnDatabase[preq.GetOriginatorAddress()] = preq.GetOriginatorSeqNumber();
-		m_preqMetricDatabase[preq.GetOriginatorAddress()] = preq.GetMetric();
-	}
-	else
-	{
-		if(i->second > preq.GetOriginatorSeqNumber())
-			return;
-		if(i->second == preq.GetOriginatorSeqNumber())
-		{
-			//find metric
-			std::map<Mac48Address, uint32_t, mac48addrComparator>::iterator j = 
-				m_preqMetricDatabase.find(preq.GetOriginatorAddress());
-			NS_ASSERT(j != m_dsnDatabase.end());
-			if(j->second <= preq.GetMetric())
-				return;
-		}
-		m_dsnDatabase[preq.GetOriginatorAddress()] = preq.GetOriginatorSeqNumber();
-		m_preqMetricDatabase[preq.GetOriginatorAddress()] = preq.GetMetric();
-	}
-	NS_LOG_DEBUG(
-			"PREQ from "<< preq.GetOriginatorAddress()
-			<<", at "<< m_address
-			<<", TTL ="<< (int)preq.GetTtl()
-			<<", metric = "<< preq.GetMetric()
-			<<", hopcount = "<< (int)preq.GetHopCount()
-			<<", preqId = "<< preq.GetPreqID()
-			<<", transmitter is "<<from);
-	//fill routingTable
-	INFO newInfo;
-	newInfo.me = m_address;
-	newInfo.destination = preq.GetOriginatorAddress();
-	newInfo.nextHop = from;
-	newInfo.metric = preq.GetMetric();
-	newInfo.lifetime = TU_TO_TIME(preq.GetLifetime());
-	newInfo.outPort = m_ifIndex;
-	newInfo.dsn = preq.GetOriginatorSeqNumber();
-	newInfo.type = INFO_PREQ;
-	//check if can answer:
-	std::vector<Ptr<DestinationAddressUnit> > destinations = preq.GetDestinationList ();
-	for(std::vector<Ptr<DestinationAddressUnit> >::iterator i = destinations.begin(); i!= destinations.end(); i++)
-	{
-		if((*i)->GetDestinationAddress() == Mac48Address::GetBroadcast())
-		{
-			//only proactive PREQ contains destination
-			//address as broadcast! Proactive preq MUST
-			//have destination count equal to 1 and
-			//per destination flags DO and RF
-			NS_ASSERT(preq.GetDestCount() == 1);
-			NS_ASSERT(((*i)->IsDo()) && ((*i)->IsRf()));
-			NS_LOG_DEBUG("PROACTIVE PREQ RECEIVED");
-			newInfo.type = INFO_PROACTIVE;
-			m_routingInfoCallback(newInfo);
-			if(!preq.IsNeedNotPrep())
-			{
-				SendPrep(
-						preq.GetOriginatorAddress(),
-						m_address,
-						from,
-						preq.GetMetric(),
-						preq.GetOriginatorSeqNumber(),
-						m_myDsn ++,
-						preq.GetLifetime()
-						);
-				if(m_myDsn == MAX_DSN)
-					m_myDsn = 0;
-			}
-			break;
-		}
-		if((*i)->GetDestinationAddress()==m_address)
-		{
-			preq.DelDestinationAddressElement((*i)->GetDestinationAddress());
-			SendPrep(
-					preq.GetOriginatorAddress(),
-					m_address,
-					from,
-					0,
-					preq.GetOriginatorSeqNumber(),
-					m_myDsn++,
-					preq.GetLifetime()
-					);
-			if(m_myDsn == MAX_DSN)
-				m_myDsn = 0;
-			continue;
-		}
-		//check if can answer:
-		HwmpRtable::LookupResult result = m_requestRouteCallback((*i)->GetDestinationAddress());
-		if((!((*i)->IsDo())) && (result.retransmitter!=Mac48Address::GetBroadcast()))
-		{
-			//have a valid information and acn answer
-			if((*i)->IsRf())
-				(*i)->SetFlags(true, false); //DO = 1, RF = 0 (as it was)
-			else
-			{
-				//send a PREP and delete destination
-				preq.DelDestinationAddressElement((*i)->GetDestinationAddress());
-				SendPrep(
-						preq.GetOriginatorAddress(),
-						(*i)->GetDestinationAddress(),
-						result.retransmitter,
-						result.metric,
-						preq.GetOriginatorSeqNumber(),
-						result.seqnum,
-						preq.GetLifetime()
-						);
-				continue;
-			}
-		}
-	}
-	m_routingInfoCallback(newInfo);
-	//chack if must retransmit:
-	if(preq.GetDestCount() == 0)
-		return;
-	if(m_preqTimer.IsRunning())
-	{
-		m_preqQueue.push_back(preq);
-	}
-	else
-	{
-		m_preqCallback(preq);
-		NS_ASSERT(!m_preqTimer.IsRunning());
-		m_preqTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPpreqMinInterval, &HwmpState::SendOnePreq, this);
-	}
+  if (m_disabled)
+    return;
+  if (preq.GetOriginatorAddress() == m_address)
+    return;
+  preq.DecrementTtl();
+  preq.IncrementMetric(metric);
+  if (preq.GetTtl() == 0)
+    return;
+  //acceptance cretirea:
+  std::map<Mac48Address, uint32_t, mac48addrComparator>::iterator i = m_dsnDatabase.find(preq.GetOriginatorAddress());
+  if (i == m_dsnDatabase.end())
+    {
+      m_dsnDatabase[preq.GetOriginatorAddress()] = preq.GetOriginatorSeqNumber();
+      m_preqMetricDatabase[preq.GetOriginatorAddress()] = preq.GetMetric();
+    }
+  else
+    {
+      if (i->second > preq.GetOriginatorSeqNumber())
+        return;
+      if (i->second == preq.GetOriginatorSeqNumber())
+        {
+          //find metric
+          std::map<Mac48Address, uint32_t, mac48addrComparator>::iterator j =
+            m_preqMetricDatabase.find(preq.GetOriginatorAddress());
+          NS_ASSERT(j != m_dsnDatabase.end());
+          if (j->second <= preq.GetMetric())
+            return;
+        }
+      m_dsnDatabase[preq.GetOriginatorAddress()] = preq.GetOriginatorSeqNumber();
+      m_preqMetricDatabase[preq.GetOriginatorAddress()] = preq.GetMetric();
+    }
+  NS_LOG_DEBUG(
+    "PREQ from "<< preq.GetOriginatorAddress()
+    <<", at "<< m_address
+    <<", TTL ="<< (int)preq.GetTtl()
+    <<", metric = "<< preq.GetMetric()
+    <<", hopcount = "<< (int)preq.GetHopCount()
+    <<", preqId = "<< preq.GetPreqID()
+    <<", transmitter is "<<from);
+  //fill routingTable
+  INFO newInfo;
+  newInfo.me = m_address;
+  newInfo.destination = preq.GetOriginatorAddress();
+  newInfo.nextHop = from;
+  newInfo.metric = preq.GetMetric();
+  newInfo.lifetime = TU_TO_TIME(preq.GetLifetime());
+  newInfo.outPort = m_ifIndex;
+  newInfo.dsn = preq.GetOriginatorSeqNumber();
+  newInfo.type = INFO_PREQ;
+  //check if can answer:
+  std::vector<Ptr<DestinationAddressUnit> > destinations = preq.GetDestinationList ();
+  for (std::vector<Ptr<DestinationAddressUnit> >::iterator i = destinations.begin(); i != destinations.end(); i++)
+    {
+      if ((*i)->GetDestinationAddress() == Mac48Address::GetBroadcast())
+        {
+          //only proactive PREQ contains destination
+          //address as broadcast! Proactive preq MUST
+          //have destination count equal to 1 and
+          //per destination flags DO and RF
+          NS_ASSERT(preq.GetDestCount() == 1);
+          NS_ASSERT(((*i)->IsDo()) && ((*i)->IsRf()));
+          NS_LOG_DEBUG("PROACTIVE PREQ RECEIVED");
+          newInfo.type = INFO_PROACTIVE;
+          m_routingInfoCallback(newInfo);
+          if (!preq.IsNeedNotPrep())
+            {
+              SendPrep(
+                preq.GetOriginatorAddress(),
+                m_address,
+                from,
+                preq.GetMetric(),
+                preq.GetOriginatorSeqNumber(),
+                m_myDsn ++,
+                preq.GetLifetime()
+              );
+              if (m_myDsn == MAX_DSN)
+                m_myDsn = 0;
+            }
+          break;
+        }
+      if ((*i)->GetDestinationAddress()==m_address)
+        {
+          preq.DelDestinationAddressElement((*i)->GetDestinationAddress());
+          SendPrep(
+            preq.GetOriginatorAddress(),
+            m_address,
+            from,
+            0,
+            preq.GetOriginatorSeqNumber(),
+            m_myDsn++,
+            preq.GetLifetime()
+          );
+          if (m_myDsn == MAX_DSN)
+            m_myDsn = 0;
+          continue;
+        }
+      //check if can answer:
+      HwmpRtable::LookupResult result = m_requestRouteCallback((*i)->GetDestinationAddress());
+      if ((!((*i)->IsDo())) && (result.retransmitter!=Mac48Address::GetBroadcast()))
+        {
+          //have a valid information and acn answer
+          if ((*i)->IsRf())
+            (*i)->SetFlags(true, false); //DO = 1, RF = 0 (as it was)
+          else
+            {
+              //send a PREP and delete destination
+              preq.DelDestinationAddressElement((*i)->GetDestinationAddress());
+              SendPrep(
+                preq.GetOriginatorAddress(),
+                (*i)->GetDestinationAddress(),
+                result.retransmitter,
+                result.metric,
+                preq.GetOriginatorSeqNumber(),
+                result.seqnum,
+                preq.GetLifetime()
+              );
+              continue;
+            }
+        }
+    }
+  m_routingInfoCallback(newInfo);
+  //chack if must retransmit:
+  if (preq.GetDestCount() == 0)
+    return;
+  if (m_preqTimer.IsRunning())
+    {
+      m_preqQueue.push_back(preq);
+    }
+  else
+    {
+      m_preqCallback(preq);
+      NS_ASSERT(!m_preqTimer.IsRunning());
+      m_preqTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPpreqMinInterval, &HwmpState::SendOnePreq, this);
+    }
 }
 
 void
 HwmpState::ReceivePrep(WifiPrepInformationElement& prep, const Mac48Address& from, const uint32_t& metric)
 {
-	if(m_disabled)
-		return;
-	prep.DecrementTtl();
-	prep.IncrementMetric(metric);
-	//acceptance cretirea:
-	std::map<Mac48Address, uint32_t, mac48addrComparator>::iterator i = m_dsnDatabase.find(prep.GetDestinationAddress());
-	if(i == m_dsnDatabase.end())
-	{
-		m_dsnDatabase[prep.GetDestinationAddress()] = prep.GetDestinationSeqNumber();
-	}
-	else
-		if(i->second > prep.GetDestinationSeqNumber())
-			return;
-	//update routing info
-	HwmpRtable::LookupResult result = m_requestRouteCallback(prep.GetDestinationAddress());
-	if(result.retransmitter == Mac48Address::GetBroadcast())
-		//try to look for default route
-		result = m_requestRootPathCallback(m_ifIndex);
-	if((result.retransmitter == Mac48Address::GetBroadcast())&&(m_address != prep.GetDestinationAddress()))
-		return;
-	INFO newInfo;
-	newInfo.me = m_address;
-	newInfo.destination = prep.GetOriginatorAddress();
-	newInfo.source = prep.GetDestinationAddress();
-	newInfo.nextHop = from;
-	newInfo.metric = prep.GetMetric();
-	newInfo.lifetime = TU_TO_TIME(prep.GetLifetime());
-	newInfo.outPort = m_ifIndex;
-	newInfo.dsn = prep.GetOriginatorSeqNumber();
-	newInfo.prevHop = result.retransmitter;
-	newInfo.type = INFO_PREP;
-	NS_LOG_DEBUG("Path to "<<newInfo.source<<", i am "<<m_address<<", precursor is "<<from);
-	NS_LOG_DEBUG("Path to "<<newInfo.destination<<", i am "<<m_address<<", precursor is "<<result.retransmitter);
-	m_routingInfoCallback(newInfo);
-	if(prep.GetDestinationAddress() == m_address)
-	{
-		NS_LOG_DEBUG("Destination resolved"<<newInfo.destination);
-		return;
-	}
-	m_prepCallback(prep, result.retransmitter);
+  if (m_disabled)
+    return;
+  prep.DecrementTtl();
+  prep.IncrementMetric(metric);
+  //acceptance cretirea:
+  std::map<Mac48Address, uint32_t, mac48addrComparator>::iterator i = m_dsnDatabase.find(prep.GetDestinationAddress());
+  if (i == m_dsnDatabase.end())
+    {
+      m_dsnDatabase[prep.GetDestinationAddress()] = prep.GetDestinationSeqNumber();
+    }
+  else
+    if (i->second > prep.GetDestinationSeqNumber())
+      return;
+  //update routing info
+  HwmpRtable::LookupResult result = m_requestRouteCallback(prep.GetDestinationAddress());
+  if (result.retransmitter == Mac48Address::GetBroadcast())
+    //try to look for default route
+    result = m_requestRootPathCallback(m_ifIndex);
+  if ((result.retransmitter == Mac48Address::GetBroadcast())&&(m_address != prep.GetDestinationAddress()))
+    return;
+  INFO newInfo;
+  newInfo.me = m_address;
+  newInfo.destination = prep.GetOriginatorAddress();
+  newInfo.source = prep.GetDestinationAddress();
+  newInfo.nextHop = from;
+  newInfo.metric = prep.GetMetric();
+  newInfo.lifetime = TU_TO_TIME(prep.GetLifetime());
+  newInfo.outPort = m_ifIndex;
+  newInfo.dsn = prep.GetOriginatorSeqNumber();
+  newInfo.prevHop = result.retransmitter;
+  newInfo.type = INFO_PREP;
+  NS_LOG_DEBUG("Path to "<<newInfo.source<<", i am "<<m_address<<", precursor is "<<from);
+  NS_LOG_DEBUG("Path to "<<newInfo.destination<<", i am "<<m_address<<", precursor is "<<result.retransmitter);
+  m_routingInfoCallback(newInfo);
+  if (prep.GetDestinationAddress() == m_address)
+    {
+      NS_LOG_DEBUG("Destination resolved"<<newInfo.destination);
+      return;
+    }
+  m_prepCallback(prep, result.retransmitter);
 }
 
 void
 HwmpState::ReceivePerr(WifiPerrInformationElement& perr, const Mac48Address& from)
 {
-	if(m_disabled)
-		return;
-	NS_LOG_DEBUG(m_address<<" RECEIVED PERR from "<<from);
-	/**
-	 * Check forwarding conditions:
-	 */
-	std::vector<HwmpRtable::FailedDestination> destinations = perr.GetAddressUnitVector();
-	for(unsigned int i = 0; i < destinations.size(); i ++)
-	{
-		/**
-		 * Lookup for a valid routing information
-		 */
-	HwmpRtable::LookupResult result = m_requestRouteCallback(destinations[i].destination);
-	if(
-			(result.retransmitter != from)
-			||(result.seqnum >= destinations[i].seqnum)
-	  )
+  if (m_disabled)
+    return;
+  NS_LOG_DEBUG(m_address<<" RECEIVED PERR from "<<from);
+  /**
+   * Check forwarding conditions:
+   */
+  std::vector<HwmpRtable::FailedDestination> destinations = perr.GetAddressUnitVector();
+  for (unsigned int i = 0; i < destinations.size(); i ++)
+    {
+      /**
+       * Lookup for a valid routing information
+       */
+      HwmpRtable::LookupResult result = m_requestRouteCallback(destinations[i].destination);
+      if (
+        (result.retransmitter != from)
+        ||(result.seqnum >= destinations[i].seqnum)
+      )
 
-		perr.DeleteAddressUnit(destinations[i].destination);
-	}
-	NS_LOG_DEBUG("Retransmit "<<(int)perr.GetNumOfDest());
-	if(perr.GetNumOfDest() == 0)
-		return;
-	destinations = perr.GetAddressUnitVector();
-	SendPathError(destinations);
+        perr.DeleteAddressUnit(destinations[i].destination);
+    }
+  NS_LOG_DEBUG("Retransmit "<<(int)perr.GetNumOfDest());
+  if (perr.GetNumOfDest() == 0)
+    return;
+  destinations = perr.GetAddressUnitVector();
+  SendPathError(destinations);
 }
 
 void
 HwmpState::PeerStatus(const Mac48Address peerAddress, const bool status, const uint32_t metric)
 {
-	INFO newInfo;
-	newInfo.me = m_address;
-	newInfo.destination = peerAddress;
-	newInfo.nextHop = peerAddress;
-	newInfo.metric = metric;
-	newInfo.outPort = m_ifIndex;
-	newInfo.dsn = 0;
-	if(status)
-		newInfo.type = INFO_NEW_PEER;
-	else
-		newInfo.type = INFO_FAILED_PEER;
-	m_routingInfoCallback(newInfo);
+  INFO newInfo;
+  newInfo.me = m_address;
+  newInfo.destination = peerAddress;
+  newInfo.nextHop = peerAddress;
+  newInfo.metric = metric;
+  newInfo.outPort = m_ifIndex;
+  newInfo.dsn = 0;
+  if (status)
+    newInfo.type = INFO_NEW_PEER;
+  else
+    newInfo.type = INFO_FAILED_PEER;
+  m_routingInfoCallback(newInfo);
 }
 
 bool
 HwmpState::SetRoot()
 {
 #if 0
-	//TODO:: delete this lines!!!!!!!
-	if(m_address != Mac48Address("00:00:00:00:00:10"))
-		return false;
-	//TODO
+  //TODO:: delete this lines!!!!!!!
+  if (m_address != Mac48Address("00:00:00:00:00:10"))
+    return false;
+  //TODO
 #endif
-	Simulator::Schedule(dot11sParameters::dot11MeshHWMPactiveRootTimeout, &HwmpState::SendProactivePreq, this);
-	return true;
+  Simulator::Schedule(dot11sParameters::dot11MeshHWMPactiveRootTimeout, &HwmpState::SendProactivePreq, this);
+  return true;
 }
 
 void
 HwmpState::SendProactivePreq()
 {
-	NS_LOG_DEBUG("Sending proactive PREQ");
-	WifiPreqInformationElement preq;
-	//By default: must answer
-	preq.SetHopcount(0);
-	preq.SetTTL(m_maxTtl);
-	preq.SetPreqID(m_preqId++);
-	if(m_preqId == MAX_PREQ_ID)
-		m_preqId = 0;
-	preq.SetLifetime(TIME_TO_TU(dot11sParameters::dot11MeshHWMPpathToRootInterval));
-	preq.SetOriginatorSeqNumber(m_myDsn++);
-	if(m_myDsn == MAX_DSN)
-		m_myDsn = 0;
-	preq.SetOriginatorAddress(m_address);
-	preq.AddDestinationAddressElement(
-			true,
-			true,
-			Mac48Address::GetBroadcast()
-			,0);
-	if(m_preqTimer.IsRunning())
-		m_preqQueue.push_back(preq);
-	else
-	{
-		NS_LOG_DEBUG("Send now "<<preq.GetPreqID());
-		m_preqCallback(preq);
-		NS_ASSERT(!m_preqTimer.IsRunning());
-		m_preqTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPpreqMinInterval, &HwmpState::SendOnePreq, this);
-	}
-	Simulator::Schedule(dot11sParameters::dot11MeshHWMPactiveRootTimeout, &HwmpState::SendProactivePreq, this);
+  NS_LOG_DEBUG("Sending proactive PREQ");
+  WifiPreqInformationElement preq;
+  //By default: must answer
+  preq.SetHopcount(0);
+  preq.SetTTL(m_maxTtl);
+  preq.SetPreqID(m_preqId++);
+  if (m_preqId == MAX_PREQ_ID)
+    m_preqId = 0;
+  preq.SetLifetime(TIME_TO_TU(dot11sParameters::dot11MeshHWMPpathToRootInterval));
+  preq.SetOriginatorSeqNumber(m_myDsn++);
+  if (m_myDsn == MAX_DSN)
+    m_myDsn = 0;
+  preq.SetOriginatorAddress(m_address);
+  preq.AddDestinationAddressElement(
+    true,
+    true,
+    Mac48Address::GetBroadcast()
+    ,0);
+  if (m_preqTimer.IsRunning())
+    m_preqQueue.push_back(preq);
+  else
+    {
+      NS_LOG_DEBUG("Send now "<<preq.GetPreqID());
+      m_preqCallback(preq);
+      NS_ASSERT(!m_preqTimer.IsRunning());
+      m_preqTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPpreqMinInterval, &HwmpState::SendOnePreq, this);
+    }
+  Simulator::Schedule(dot11sParameters::dot11MeshHWMPactiveRootTimeout, &HwmpState::SendProactivePreq, this);
 }
 
 void
 HwmpState::AddPerrReceiver(Mac48Address receiver)
 {
-	/**
-	 * add new vector of addresses to m_perrReceiversand check
-	 * duplicates
-	 */
-	for(unsigned int j = 0; j < m_myPerrReceivers.size(); j++)
-		if(m_myPerrReceivers[j] == receiver)
-			return;
-	m_myPerrReceivers.push_back(receiver);
+  /**
+   * add new vector of addresses to m_perrReceiversand check
+   * duplicates
+   */
+  for (unsigned int j = 0; j < m_myPerrReceivers.size(); j++)
+    if (m_myPerrReceivers[j] == receiver)
+      return;
+  m_myPerrReceivers.push_back(receiver);
 }
 
 void
@@ -470,70 +470,70 @@ HwmpState::UnSetRoot()
 void
 HwmpState::Disable()
 {
-	m_disabled = true;
+  m_disabled = true;
 }
 
 void
 HwmpState::Enable()
 {
-	m_disabled = false;
+  m_disabled = false;
 }
 
 Mac48Address
 HwmpState::GetAddress()
 {
-	return m_address;
+  return m_address;
 }
 
 void
 HwmpState::SendOnePreq()
 {
-	if(m_preqQueue.size() == 0)
-		return;
-	if(m_myPreq == m_preqQueue.begin())
-		m_myPreq == m_preqQueue.end();
-	WifiPreqInformationElement preq = m_preqQueue[0];
-	NS_LOG_DEBUG(
-			"Sending PREQ from "<<preq.GetOriginatorAddress() <<
-			" destinations are  "<<(int)preq.GetDestCount()<<
-			", at "<<Simulator::Now()<<
-			", store in queue "<<m_preqQueue.size()<<
-			" preqs"<<", I am "<<m_address);
-	m_preqCallback(preq);
-	//erase first!
-	m_preqQueue.erase(m_preqQueue.begin());
-	//reschedule sending PREQ
-		NS_ASSERT(!m_preqTimer.IsRunning());
-	m_preqTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPpreqMinInterval, &HwmpState::SendOnePreq, this);
+  if (m_preqQueue.size() == 0)
+    return;
+  if (m_myPreq == m_preqQueue.begin())
+    m_myPreq == m_preqQueue.end();
+  WifiPreqInformationElement preq = m_preqQueue[0];
+  NS_LOG_DEBUG(
+    "Sending PREQ from "<<preq.GetOriginatorAddress() <<
+    " destinations are  "<<(int)preq.GetDestCount()<<
+    ", at "<<Simulator::Now()<<
+    ", store in queue "<<m_preqQueue.size()<<
+    " preqs"<<", I am "<<m_address);
+  m_preqCallback(preq);
+  //erase first!
+  m_preqQueue.erase(m_preqQueue.begin());
+  //reschedule sending PREQ
+  NS_ASSERT(!m_preqTimer.IsRunning());
+  m_preqTimer = Simulator::Schedule(dot11sParameters::dot11MeshHWMPpreqMinInterval, &HwmpState::SendOnePreq, this);
 }
 
 void
 HwmpState::SendPrep(Mac48Address dst,
-		Mac48Address src,
-		Mac48Address retransmitter,
-		uint32_t initMetric,
-		uint32_t dsn,
-		uint32_t originatorDsn,
-		uint32_t lifetime)
+                    Mac48Address src,
+                    Mac48Address retransmitter,
+                    uint32_t initMetric,
+                    uint32_t dsn,
+                    uint32_t originatorDsn,
+                    uint32_t lifetime)
 {
-	WifiPrepInformationElement prep;
-	prep.SetHopcount(0);
-	prep.SetTTL(m_maxTtl);
-	prep.SetDestinationAddress(dst);
-	prep.SetDestinationSeqNumber(dsn);
-	prep.SetLifetime(lifetime);
-	prep.SetMetric(0);
-	prep.SetOriginatorAddress(src);
-	prep.SetOriginatorSeqNumber(originatorDsn);
-	m_prepCallback(prep, retransmitter);
+  WifiPrepInformationElement prep;
+  prep.SetHopcount(0);
+  prep.SetTTL(m_maxTtl);
+  prep.SetDestinationAddress(dst);
+  prep.SetDestinationSeqNumber(dsn);
+  prep.SetLifetime(lifetime);
+  prep.SetMetric(0);
+  prep.SetOriginatorAddress(src);
+  prep.SetOriginatorSeqNumber(originatorDsn);
+  m_prepCallback(prep, retransmitter);
 }
 
 void
 HwmpState::SendOnePerr()
 {
-	if(m_myPerr.GetNumOfDest() == 0)
-		return;
-	m_perrCallback(m_myPerr, m_myPerrReceivers);
-	m_myPerr.ResetPerr();
+  if (m_myPerr.GetNumOfDest() == 0)
+    return;
+  m_perrCallback(m_myPerr, m_myPerrReceivers);
+  m_myPerr.ResetPerr();
 }
 }//namespace ns3
diff --git a/src/devices/l2-routing/l2-routing-hwmp/hwmp-state.h b/src/devices/l2-routing/l2-routing-hwmp/hwmp-state.h
index a0e9de58d..aea16ac2a 100644
--- a/src/devices/l2-routing/l2-routing-hwmp/hwmp-state.h
+++ b/src/devices/l2-routing/l2-routing-hwmp/hwmp-state.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -33,164 +33,157 @@
 #include "ns3/mesh-wifi-perr-information-element.h"
 #include "ns3/dot11s-parameters.h"
 namespace ns3 {
-	/**
-	 * \ingroup mesh
-	 * 
-	 * \brief Handles HWMP state machine at each real interface
-	 * 
-	 * \details Implements the following:
-	 * 	1. Keep it's own DSN,
-	 * 	2. Keep PREQ and PREP timers adn send this frames in
-	 * 	accordance with HWMP-limitations
-	 * 	3. Deliver routing information to Hwmp main class
-	 * 	4. Notify about broken peers
-	 */
-	class HwmpState : public Object {
-		public:
-			static TypeId GetTypeId();
-			HwmpState();
-			~HwmpState();
+/**
+ * \ingroup mesh
+ *
+ * \brief Handles HWMP state machine at each real interface
+ *
+ * \details Implements the following:
+ *  1. Keep it's own DSN,
+ *  2. Keep PREQ and PREP timers adn send this frames in
+ *  accordance with HWMP-limitations
+ *  3. Deliver routing information to Hwmp main class
+ *  4. Notify about broken peers
+ */
+class HwmpState : public Object {
+public:
+  static TypeId GetTypeId();
+  HwmpState();
+  ~HwmpState();
 
-			/**
-			 * \brief Interface with HWMP - Hwmp can only
-			 * request address and collect routing
-			 * information
-			 */
-			void	SetRequestRouteCallback(
-					Callback<HwmpRtable::LookupResult, const Mac48Address&> cb);
-			void	SetRequestRootPathCallback(
-					Callback<HwmpRtable::LookupResult, uint32_t> cb);
+  /**
+   * \brief Interface with HWMP - Hwmp can only
+   * request address and collect routing
+   * information
+   */
+  void SetRequestRouteCallback(
+    Callback<HwmpRtable::LookupResult, const Mac48Address&> cb);
+  void SetRequestRootPathCallback(
+    Callback<HwmpRtable::LookupResult, uint32_t> cb);
 
-			enum InfoType {
-				INFO_PREQ,
-				INFO_PREP,
-				INFO_PERR,
-				INFO_PROACTIVE,
-				INFO_NEW_PEER,
-				INFO_FAILED_PEER
-			};
-			typedef struct RoutingInfo{
-				Mac48Address	me;
-				Mac48Address	destination;
-				Mac48Address	source;
-				Mac48Address	nextHop;
-				Mac48Address	prevHop;
-				uint32_t	outPort;
-				uint32_t	metric;
-				std::vector<Mac48Address>
-						failedDestinations;
-				uint32_t	dsn;
-				Time		lifetime;
-				enum InfoType	type;
-			} INFO;
-			void	SetRoutingInfoCallback(
-					Callback<void, INFO> cb
-					);
-			void	SetRetransmittersOfPerrCallback(
-					Callback<std::vector<Mac48Address>, std::vector<HwmpRtable::FailedDestination>, uint32_t> cb);
-			void	RequestDestination(Mac48Address dest);
-			void	SendPathError(std::vector<HwmpRtable::FailedDestination> destinations);
-			void	SetAssociatedIfaceId(uint32_t interface);
-			uint32_t
-				GetAssociatedIfaceId();
-			//Mac interaction:
-			void	SetMac(Ptr<MeshWifiMac> mac);
-			void	SetSendPreqCallback(
-					Callback<void, const WifiPreqInformationElement&> cb);
-			void	SetSendPrepCallback(
-					Callback<void, const WifiPrepInformationElement&> cb);
-			void	SetSendPerrCallback(
-					Callback<void, const WifiPerrInformationElement&, std::vector<Mac48Address> > cb);
-			void	ReceivePreq(WifiPreqInformationElement&, const Mac48Address& from, const uint32_t& metric);
-			void	ReceivePrep(WifiPrepInformationElement&, const Mac48Address& from, const uint32_t& metric);
-			void	ReceivePerr(WifiPerrInformationElement&, const Mac48Address& from);
-			void	PeerStatus(
-					const Mac48Address peerAddress,
-					const bool status,
-					const uint32_t metric
-					);
-			//Proactive mode routines:
-			bool	SetRoot();
-			void	UnSetRoot();
-			//external handling:
-			void	Disable();
-			void	Enable();
-			//DEBUG purpose:
-			Mac48Address GetAddress();
-		private:
-			static const uint32_t MAX_PREQ_ID = 0xffffffff;
-			static const uint32_t MAX_DSN = 0xffffffff;
-			//information about associated port:
-			Mac48Address	m_address;
-			//index when HWMP state is attached
-			uint32_t	m_ifIndex;
-			//timers for PREQ and PREP:
-			EventId		m_preqTimer;
-			void		SendOnePreq();
-			std::vector<WifiPreqInformationElement>
-					m_preqQueue;
-			//true means that we can add a destination to
-			//existing PREQ element
-			//False means that we must send 
-			EventId		m_prepTimer;
-			void		SendPrep(
-					Mac48Address	dst, //dst is PREQ's originator address
-					Mac48Address	src, //src is PREQ's destination address
-					Mac48Address	retransmitter,
-					uint32_t	initMetric,
-					uint32_t	dsn,/* taken form PREQ*/
-					uint32_t	originatorDsn, //taken from rtable or as m_myDsn ++;
-					uint32_t	lifetime	//taken from PREQ
-					);
-			std::vector<WifiPreqInformationElement>::iterator
-					m_myPreq;
-			//HWMP interaction callbacks:
-			Callback<void, INFO>
-					m_routingInfoCallback;
-			Callback<std::vector<Mac48Address>, std::vector<HwmpRtable::FailedDestination>, uint32_t>
-					m_retransmittersOfPerrCallback;
-			Callback<HwmpRtable::LookupResult, const Mac48Address&>
-					m_requestRouteCallback;
-			Callback<HwmpRtable::LookupResult, uint32_t>
-					m_requestRootPathCallback;
-			//Mac interaction callbacks:
-			Callback<void, const WifiPreqInformationElement&>
-					m_preqCallback;
-			Callback<void, const WifiPrepInformationElement&, const Mac48Address&>
-					m_prepCallback;
-			Callback<void, const WifiPerrInformationElement&, std::vector<Mac48Address> >
-					m_perrCallback;
-			//HwmpCounters:
-			uint32_t	m_preqId;
-			uint32_t	m_myDsn;
-			//Seqno and metric database
-			std::map<Mac48Address, uint32_t, mac48addrComparator>
-					m_dsnDatabase;
-			std::map<Mac48Address, uint32_t, mac48addrComparator>
-					m_preqMetricDatabase;
-			//Disable/enable functionality
-			bool		m_disabled;
-			//Proactive PREQ mechanism:
-			EventId		m_proactivePreqTimer;
-			void		SendProactivePreq();
-			/**
-			 * \brief Two PERRs may not be sent closer to
-			 * each other than
-			 * dot11MeshHWMPperrMinInterval, so, each HWMP
-			 * state collects all unreachable destinations
-			 * and once in dot11MeshHWMPperrMinInterval
-			 * should send PERR, and PERR element should
-			 * be cleared
-			 */
-			WifiPerrInformationElement
-					m_myPerr;
-			std::vector<Mac48Address>
-					m_myPerrReceivers;
-			void		AddPerrReceiver(Mac48Address receiver);
-			EventId		m_perrTimer;
-			void		SendOnePerr();
-			//Configurable parameters:
-			uint8_t		m_maxTtl;
-	};
+  enum InfoType {
+    INFO_PREQ,
+    INFO_PREP,
+    INFO_PERR,
+    INFO_PROACTIVE,
+    INFO_NEW_PEER,
+    INFO_FAILED_PEER
+  };
+  typedef struct RoutingInfo {
+    Mac48Address me;
+    Mac48Address destination;
+    Mac48Address source;
+    Mac48Address nextHop;
+    Mac48Address prevHop;
+    uint32_t outPort;
+    uint32_t metric;
+    std::vector<Mac48Address>  failedDestinations;
+    uint32_t dsn;
+    Time  lifetime;
+    enum InfoType type;
+  } INFO;
+  void SetRoutingInfoCallback(
+    Callback<void, INFO> cb
+  );
+  void SetRetransmittersOfPerrCallback(
+    Callback<std::vector<Mac48Address>, std::vector<HwmpRtable::FailedDestination>, uint32_t> cb);
+  void RequestDestination(Mac48Address dest);
+  void SendPathError(std::vector<HwmpRtable::FailedDestination> destinations);
+  void SetAssociatedIfaceId(uint32_t interface);
+  uint32_t  GetAssociatedIfaceId();
+  //Mac interaction:
+  void SetMac(Ptr<MeshWifiMac> mac);
+  void SetSendPreqCallback(
+    Callback<void, const WifiPreqInformationElement&> cb);
+  void SetSendPrepCallback(
+    Callback<void, const WifiPrepInformationElement&> cb);
+  void SetSendPerrCallback(
+    Callback<void, const WifiPerrInformationElement&, std::vector<Mac48Address> > cb);
+  void ReceivePreq(WifiPreqInformationElement&, const Mac48Address& from, const uint32_t& metric);
+  void ReceivePrep(WifiPrepInformationElement&, const Mac48Address& from, const uint32_t& metric);
+  void ReceivePerr(WifiPerrInformationElement&, const Mac48Address& from);
+  void PeerStatus(
+    const Mac48Address peerAddress,
+    const bool status,
+    const uint32_t metric
+  );
+  //Proactive mode routines:
+  bool SetRoot();
+  void UnSetRoot();
+  //external handling:
+  void Disable();
+  void Enable();
+  //DEBUG purpose:
+  Mac48Address GetAddress();
+private:
+  static const uint32_t MAX_PREQ_ID = 0xffffffff;
+  static const uint32_t MAX_DSN = 0xffffffff;
+  //information about associated port:
+  Mac48Address m_address;
+  //index when HWMP state is attached
+  uint32_t m_ifIndex;
+  //timers for PREQ and PREP:
+  EventId  m_preqTimer;
+  void  SendOnePreq();
+  std::vector<WifiPreqInformationElement>
+  m_preqQueue;
+  //true means that we can add a destination to
+  //existing PREQ element
+  //False means that we must send
+  EventId  m_prepTimer;
+  void  SendPrep(
+    Mac48Address dst, //dst is PREQ's originator address
+    Mac48Address src, //src is PREQ's destination address
+    Mac48Address retransmitter,
+    uint32_t initMetric,
+    uint32_t dsn,/* taken form PREQ*/
+    uint32_t originatorDsn, //taken from rtable or as m_myDsn ++;
+    uint32_t lifetime //taken from PREQ
+  );
+  std::vector<WifiPreqInformationElement>::iterator
+  m_myPreq;
+  //HWMP interaction callbacks:
+  Callback<void, INFO>
+  m_routingInfoCallback;
+  Callback<std::vector<Mac48Address>, std::vector<HwmpRtable::FailedDestination>, uint32_t>
+  m_retransmittersOfPerrCallback;
+  Callback<HwmpRtable::LookupResult, const Mac48Address&>
+  m_requestRouteCallback;
+  Callback<HwmpRtable::LookupResult, uint32_t>
+  m_requestRootPathCallback;
+  //Mac interaction callbacks:
+  Callback<void, const WifiPreqInformationElement&>  m_preqCallback;
+  Callback<void, const WifiPrepInformationElement&, const Mac48Address&>
+  m_prepCallback;
+  Callback<void, const WifiPerrInformationElement&, std::vector<Mac48Address> >
+  m_perrCallback;
+  //HwmpCounters:
+  uint32_t m_preqId;
+  uint32_t m_myDsn;
+  //Seqno and metric database
+  std::map<Mac48Address, uint32_t, mac48addrComparator>  m_dsnDatabase;
+  std::map<Mac48Address, uint32_t, mac48addrComparator>  m_preqMetricDatabase;
+  //Disable/enable functionality
+  bool  m_disabled;
+  //Proactive PREQ mechanism:
+  EventId  m_proactivePreqTimer;
+  void  SendProactivePreq();
+  /**
+   * \brief Two PERRs may not be sent closer to
+   * each other than
+   * dot11MeshHWMPperrMinInterval, so, each HWMP
+   * state collects all unreachable destinations
+   * and once in dot11MeshHWMPperrMinInterval
+   * should send PERR, and PERR element should
+   * be cleared
+   */
+  WifiPerrInformationElement  m_myPerr;
+  std::vector<Mac48Address>   m_myPerrReceivers;
+  void  AddPerrReceiver(Mac48Address receiver);
+  EventId  m_perrTimer;
+  void  SendOnePerr();
+  //Configurable parameters:
+  uint8_t  m_maxTtl;
+};
 } //namespace ns3
 #endif
diff --git a/src/devices/l2-routing/l2-routing-hwmp/hwmp.cc b/src/devices/l2-routing/l2-routing-hwmp/hwmp.cc
index a7808029b..1f93705bb 100644
--- a/src/devices/l2-routing/l2-routing-hwmp/hwmp.cc
+++ b/src/devices/l2-routing/l2-routing-hwmp/hwmp.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -41,125 +41,125 @@ HwmpTag::~HwmpTag()
 void
 HwmpTag::SetAddress(Mac48Address retransmitter)
 {
-	m_address = retransmitter;
+  m_address = retransmitter;
 }
 
 Mac48Address
 HwmpTag::GetAddress()
 {
-	return m_address;
+  return m_address;
 }
 
 void
 HwmpTag::SetTtl(uint8_t ttl)
 {
-	m_ttl = ttl;
+  m_ttl = ttl;
 }
 
 uint8_t
 HwmpTag::GetTtl()
 {
-	return m_ttl;
+  return m_ttl;
 }
 
 void
 HwmpTag::SetMetric(uint32_t metric)
 {
-	m_metric = metric;
+  m_metric = metric;
 }
 
 uint32_t
 HwmpTag::GetMetric()
 {
-	return m_metric;
+  return m_metric;
 }
 
 void
 HwmpTag::SetSeqno(uint32_t seqno)
 {
-	m_seqno = seqno;
+  m_seqno = seqno;
 }
 
 uint32_t
 HwmpTag::GetSeqno()
 {
-	return m_seqno;
+  return m_seqno;
 }
 
 TypeId
 HwmpTag::GetTypeId ()
 {
-	static TypeId tid = TypeId ("ns3::HwmpTag")
-		.SetParent<Tag> ()
-		.AddConstructor<HwmpTag> ()
-		;
-	return tid;
+  static TypeId tid = TypeId ("ns3::HwmpTag")
+                      .SetParent<Tag> ()
+                      .AddConstructor<HwmpTag> ()
+                      ;
+  return tid;
 }
 
 TypeId
 HwmpTag::GetInstanceTypeId() const
-{
-	return GetTypeId();
-}
+  {
+    return GetTypeId();
+  }
 
 uint32_t
 HwmpTag::GetSerializedSize() const
-{
+  {
 
-	return 6	//address
-		+1	//ttl
-		+4;	//metric
-}
+    return  6 //address
+           +1 //ttl
+           +4; //metric
+  }
 
 void
 HwmpTag::Serialize(TagBuffer i) const
-{
-	uint8_t address[6];
-	int j;
-	m_address.CopyTo(address);
-	i.WriteU8(m_ttl);
-	i.WriteU32(m_metric);
-	for(j = 0;j < 6;j ++)
-		i.WriteU8(address[j]);
-}
+  {
+    uint8_t address[6];
+    int j;
+    m_address.CopyTo(address);
+    i.WriteU8 (m_ttl);
+    i.WriteU32 (m_metric);
+    for (j = 0; j < 6; j ++)
+      i.WriteU8 (address[j]);
+  }
 
 void
 HwmpTag::Deserialize (TagBuffer i)
 {
-	uint8_t address[6];
-	int j;
-	m_ttl = i.ReadU8();
-	m_metric = i.ReadU32();
-	for(j = 0;j < 6;j ++)
-		address[j] = i.ReadU8();
-	m_address.CopyFrom(address);
+  uint8_t address[6];
+  int j;
+  m_ttl = i.ReadU8();
+  m_metric = i.ReadU32();
+  for (j = 0; j < 6; j ++)
+    address[j] = i.ReadU8();
+  m_address.CopyFrom(address);
 }
 
 void
 HwmpTag::Print (std::ostream &os) const
-{
-	os	<<	"address="	<<	m_address;
-	os	<<	"ttl="		<< 	m_ttl;
-	os	<<	"metrc="	<<	m_metric;
-}
+  {
+    os << "address=" << m_address;
+    os << "ttl="  <<  m_ttl;
+    os << "metrc=" << m_metric;
+  }
 void
 HwmpTag::DecrementTtl()
 {
-	m_ttl --;
+  m_ttl --;
 }
 //Class HWMP:
 TypeId
 Hwmp::GetTypeId ()
 {
-	static TypeId tid = TypeId ("ns3::Hwmp")
-		.SetParent<L2RoutingProtocol> ()
-                .AddConstructor<Hwmp>();
-	return tid;
+  static TypeId tid = TypeId ("ns3::Hwmp")
+                      .SetParent<L2RoutingProtocol> ()
+                      .AddConstructor<Hwmp>();
+  return tid;
 }
 Hwmp::Hwmp():
-	m_rtable(CreateObject<HwmpRtable> ()),
-	m_maxTtl(32),
-	m_broadcastPerr(false)
+    m_rtable(CreateObject<HwmpRtable> ()),
+    m_maxTtl(32),
+    m_broadcastPerr(false)
 {
 }
 
@@ -170,530 +170,529 @@ Hwmp::~Hwmp()
 void
 Hwmp::DoDispose()
 {
-	for(std::map<Mac48Address, EventId, mac48addrComparator>::iterator i = m_timeoutDatabase.begin(); i != m_timeoutDatabase.end(); i ++)
-		i->second.Cancel();
-	m_timeoutDatabase.clear();
-	m_seqnoDatabase.clear();
-	m_rtable = 0;
+  for (std::map<Mac48Address, EventId, mac48addrComparator>::iterator i = m_timeoutDatabase.begin(); i != m_timeoutDatabase.end(); i ++)
+    i->second.Cancel();
+  m_timeoutDatabase.clear();
+  m_seqnoDatabase.clear();
+  m_rtable = 0;
 
-	/**
-	 * clear routing queue:
-	 */
-	for(
-			std::map<Mac48Address, std::queue<QueuedPacket> >::iterator i =  m_rqueue.begin();
-			i != m_rqueue.end();
-			i++
-	   )
-	{
-		while(1)
-		{
-			if(i->second.empty())
-				break;
-			i->second.pop();
-		}
-	}
-	m_rqueue.clear();
-	/**
-	 * clear HWMP states
-	 */
-	for(unsigned int i = 0; i < m_hwmpStates.size(); i ++)
-		m_hwmpStates[i] = 0;
-	m_hwmpStates.clear();
+  /**
+   * clear routing queue:
+   */
+  for (
+    std::map<Mac48Address, std::queue<QueuedPacket> >::iterator i =  m_rqueue.begin();
+    i != m_rqueue.end();
+    i++
+  )
+    {
+      while (1)
+        {
+          if (i->second.empty())
+            break;
+          i->second.pop();
+        }
+    }
+  m_rqueue.clear();
+  /**
+   * clear HWMP states
+   */
+  for (unsigned int i = 0; i < m_hwmpStates.size(); i ++)
+    m_hwmpStates[i] = 0;
+  m_hwmpStates.clear();
 }
 
 bool
 Hwmp::RequestRoute(
-		uint32_t sourceIface,
-		const Mac48Address source,
-		const Mac48Address destination,
-		Ptr<Packet> packet,
-		uint16_t protocolType, //ethrnet 'Protocol' field
-		L2RoutingProtocol::RouteReplyCallback routeReply
-		)
+  uint32_t sourceIface,
+  const Mac48Address source,
+  const Mac48Address destination,
+  Ptr<Packet> packet,
+  uint16_t protocolType, //ethrnet 'Protocol' field
+  L2RoutingProtocol::RouteReplyCallback routeReply
+)
 {
-	HwmpRtable::LookupResult result;
-	HwmpTag tag;
-	if(sourceIface == m_interface)
-	{
-		if(destination == Mac48Address::GetBroadcast())
-		{
-		//set seqno!
-		tag.SetSeqno(m_seqno++);
-		if(m_seqno == MAX_SEQNO)
-			m_seqno = 0;
-		}
-		tag.SetTtl(m_maxTtl);
-	}
-	else
-	{
-		NS_ASSERT(packet->FindFirstMatchingTag(tag));
-		//check seqno!
-		if(destination == Mac48Address::GetBroadcast())
-		{
-			std::map<Mac48Address, uint32_t, mac48addrComparator>::iterator i = m_seqnoDatabase.find(source);
-			if(i == m_seqnoDatabase.end())
-				m_seqnoDatabase[source] = tag.GetSeqno();
-			else
-			{
-				if(i->second >= tag.GetSeqno())
-					return false;
-				m_seqnoDatabase[source] = tag.GetSeqno();
-			}
-		}
-	}
-	tag.SetAddress(Mac48Address::GetBroadcast());
-	if(tag.GetTtl() == 0)
-		return false;
-	tag.DecrementTtl();
-	if(destination == Mac48Address::GetBroadcast())
-	{
-		//add RA tag RA = broadcast
-		packet->RemoveAllTags();
-		packet->AddTag(tag);
-		routeReply(
-				true,
-				packet,
-				source,
-				destination,
-				protocolType,
-				HwmpRtable::PORT_ANY	
-			  );
-		return true;
-	}
-	result = m_rtable->LookupReactive(destination);
-	if (result.retransmitter == Mac48Address::GetBroadcast())
-	{
-		//no actual route exists, queue packet and start route
-		//discover procedure
-		if(sourceIface != m_interface)
-		{
-			//Start path error procedure:
-			NS_LOG_DEBUG("Must Send PERR");
-			std::vector<HwmpRtable::FailedDestination> destinations;
-			HwmpRtable::FailedDestination dst;
-			dst.seqnum = m_rtable->RequestSeqnum(destination);
-			dst.destination = destination;
-			destinations.push_back(dst);
-			StartPathErrorProcedure(destinations, result.ifIndex);
-		}
-		L2RoutingProtocol::QueuedPacket pkt;
-		packet->RemoveAllTags();
-		packet->AddTag(tag);
-		pkt.pkt = packet;
-		pkt.dst = destination;
-		pkt.src = source;
-		pkt.protocol = protocolType;
-		pkt.reply = routeReply;
-		pkt.inPort = sourceIface;
-		QueuePacket(pkt);
-		for(unsigned int i = 0; i< m_requestCallback.size(); i++)
-		{
-			if((m_modes[i] == REACTIVE) || (m_modes[i] == ROOT))
-			{
-				if(ShouldSendPreq(destination))
-					m_requestCallback[i](destination);
-			}
-			else
-			{
-				NS_ASSERT(false);
-				//PROACTIVE mode
-				//lookup a default route
-				result = m_rtable->LookupProactive(m_hwmpStates[i]->GetAssociatedIfaceId());
-				if(result.retransmitter == Mac48Address::GetBroadcast())
-				{
-					m_rtable->DeleteProactivePath(m_hwmpStates[i]->GetAssociatedIfaceId());
-					m_modes[i] = REACTIVE;
-					if(ShouldSendPreq(destination))
-						m_requestCallback[i](destination);
-					continue;
-				}
-				tag.SetAddress(result.retransmitter);
-				packet->RemoveAllTags();
-				packet->AddTag(tag);
-				routeReply(
-					true,
-					packet,
-					source,
-					destination,
-					protocolType,
-					result.ifIndex
-				  );
-			}
-		}
-		for(unsigned int i = 0; i< m_requestCallback.size(); i++)
-		{
-			m_requestCallback[i](Mac48Address("00:00:00:00:00:19"));
-
-		}
-	}
-	else
-	{
-		tag.SetAddress(result.retransmitter);
-		packet->RemoveAllTags();
-		packet->AddTag(tag);
-		routeReply(
-				true,
-				packet,
-				source,
-				destination,
-				protocolType,
-				result.ifIndex
-			  );
-	}
-	return true;
+  HwmpRtable::LookupResult result;
+  HwmpTag tag;
+  if (sourceIface == m_interface)
+    {
+      if (destination == Mac48Address::GetBroadcast())
+        {
+          //set seqno!
+          tag.SetSeqno(m_seqno++);
+          if (m_seqno == MAX_SEQNO)
+            m_seqno = 0;
+        }
+      tag.SetTtl(m_maxTtl);
+    }
+  else
+    {
+      NS_ASSERT(packet->FindFirstMatchingTag(tag));
+      //check seqno!
+      if (destination == Mac48Address::GetBroadcast())
+        {
+          std::map<Mac48Address, uint32_t, mac48addrComparator>::iterator i = m_seqnoDatabase.find(source);
+          if (i == m_seqnoDatabase.end())
+            m_seqnoDatabase[source] = tag.GetSeqno();
+          else
+            {
+              if (i->second >= tag.GetSeqno())
+                return false;
+              m_seqnoDatabase[source] = tag.GetSeqno();
+            }
+        }
+    }
+  tag.SetAddress(Mac48Address::GetBroadcast());
+  if (tag.GetTtl() == 0)
+    return false;
+  tag.DecrementTtl();
+  if (destination == Mac48Address::GetBroadcast())
+    {
+      //add RA tag RA = broadcast
+      packet->RemoveAllTags();
+      packet->AddTag(tag);
+      routeReply(
+        true,
+        packet,
+        source,
+        destination,
+        protocolType,
+        HwmpRtable::PORT_ANY
+      );
+      return true;
+    }
+  result = m_rtable->LookupReactive(destination);
+  if (result.retransmitter == Mac48Address::GetBroadcast())
+    {
+      //no actual route exists, queue packet and start route
+      //discover procedure
+      if (sourceIface != m_interface)
+        {
+          //Start path error procedure:
+          NS_LOG_DEBUG("Must Send PERR");
+          std::vector<HwmpRtable::FailedDestination> destinations;
+          HwmpRtable::FailedDestination dst;
+          dst.seqnum = m_rtable->RequestSeqnum(destination);
+          dst.destination = destination;
+          destinations.push_back(dst);
+          StartPathErrorProcedure(destinations, result.ifIndex);
+        }
+      L2RoutingProtocol::QueuedPacket pkt;
+      packet->RemoveAllTags();
+      packet->AddTag(tag);
+      pkt.pkt = packet;
+      pkt.dst = destination;
+      pkt.src = source;
+      pkt.protocol = protocolType;
+      pkt.reply = routeReply;
+      pkt.inPort = sourceIface;
+      QueuePacket(pkt);
+      for (unsigned int i = 0; i< m_requestCallback.size(); i++)
+        {
+          if ((m_modes[i] == REACTIVE) || (m_modes[i] == ROOT))
+            {
+              if (ShouldSendPreq(destination))
+                m_requestCallback[i](destination);
+            }
+          else
+            {
+              NS_ASSERT(false);
+              //PROACTIVE mode
+              //lookup a default route
+              result = m_rtable->LookupProactive(m_hwmpStates[i]->GetAssociatedIfaceId());
+              if (result.retransmitter == Mac48Address::GetBroadcast())
+                {
+                  m_rtable->DeleteProactivePath(m_hwmpStates[i]->GetAssociatedIfaceId());
+                  m_modes[i] = REACTIVE;
+                  if (ShouldSendPreq(destination))
+                    m_requestCallback[i](destination);
+                  continue;
+                }
+              tag.SetAddress(result.retransmitter);
+              packet->RemoveAllTags();
+              packet->AddTag(tag);
+              routeReply(
+                true,
+                packet,
+                source,
+                destination,
+                protocolType,
+                result.ifIndex
+              );
+            }
+        }
+      for (unsigned int i = 0; i< m_requestCallback.size(); i++)
+        {
+          m_requestCallback[i](Mac48Address("00:00:00:00:00:19"));
+        }
+    }
+  else
+    {
+      tag.SetAddress(result.retransmitter);
+      packet->RemoveAllTags();
+      packet->AddTag(tag);
+      routeReply(
+        true,
+        packet,
+        source,
+        destination,
+        protocolType,
+        result.ifIndex
+      );
+    }
+  return true;
 }
 bool
 Hwmp::AttachPorts(std::vector<Ptr<NetDevice> > ports)
 {
-	for(std::vector<Ptr<NetDevice> >::iterator i = ports.begin(); i != ports.end(); i++)
-	{
-		//Checking netdevice:
-		const WifiNetDevice * wifiNetDev = dynamic_cast<const WifiNetDevice *> (PeekPointer (*i));
-		if(wifiNetDev == NULL)
-			return false;
-		MeshWifiMac * meshWifiMac = dynamic_cast<MeshWifiMac *> (PeekPointer (wifiNetDev->GetMac()));
-		if(meshWifiMac == NULL)
-			return false;
-		//Adding HWMP-state
-		Ptr<HwmpState> hwmpState = CreateObject<HwmpState> ();
-		hwmpState->SetRoutingInfoCallback(MakeCallback(&Hwmp::ObtainRoutingInformation, this));
-		hwmpState->SetMac(meshWifiMac);
-		hwmpState->SetRequestRouteCallback(MakeCallback(&Hwmp::RequestRouteForAddress, this));
-		hwmpState->SetRequestRootPathCallback(MakeCallback(&Hwmp::RequestRootPathForPort, this));
-		hwmpState->SetAssociatedIfaceId(wifiNetDev->GetIfIndex());
-		hwmpState->SetRetransmittersOfPerrCallback(MakeCallback(&Hwmp::GetRetransmittersForFailedDestinations,this));
-		m_hwmpStates.push_back(hwmpState);
-		m_requestCallback.push_back(MakeCallback(&HwmpState::RequestDestination, hwmpState));
-		m_pathErrorCallback.push_back(MakeCallback(&HwmpState::SendPathError, hwmpState));
-		//Default mode is reactive, default state is enabled
-		enum DeviceState state = ENABLED;
-		enum DeviceMode  mode = REACTIVE;
-		m_states.push_back(state);
-		m_modes.push_back(mode);
-	}
-	return true;
+  for (std::vector<Ptr<NetDevice> >::iterator i = ports.begin(); i != ports.end(); i++)
+    {
+      //Checking netdevice:
+      const WifiNetDevice * wifiNetDev = dynamic_cast<const WifiNetDevice *> (PeekPointer (*i));
+      if (wifiNetDev == NULL)
+        return false;
+      MeshWifiMac * meshWifiMac = dynamic_cast<MeshWifiMac *> (PeekPointer (wifiNetDev->GetMac()));
+      if (meshWifiMac == NULL)
+        return false;
+      //Adding HWMP-state
+      Ptr<HwmpState> hwmpState = CreateObject<HwmpState> ();
+      hwmpState->SetRoutingInfoCallback(MakeCallback(&Hwmp::ObtainRoutingInformation, this));
+      hwmpState->SetMac(meshWifiMac);
+      hwmpState->SetRequestRouteCallback(MakeCallback(&Hwmp::RequestRouteForAddress, this));
+      hwmpState->SetRequestRootPathCallback(MakeCallback(&Hwmp::RequestRootPathForPort, this));
+      hwmpState->SetAssociatedIfaceId(wifiNetDev->GetIfIndex());
+      hwmpState->SetRetransmittersOfPerrCallback(MakeCallback(&Hwmp::GetRetransmittersForFailedDestinations,this));
+      m_hwmpStates.push_back(hwmpState);
+      m_requestCallback.push_back(MakeCallback(&HwmpState::RequestDestination, hwmpState));
+      m_pathErrorCallback.push_back(MakeCallback(&HwmpState::SendPathError, hwmpState));
+      //Default mode is reactive, default state is enabled
+      enum DeviceState state = ENABLED;
+      enum DeviceMode  mode  = REACTIVE;
+      m_states.push_back(state);
+      m_modes.push_back(mode);
+    }
+  return true;
 }
 
 void
 Hwmp::SetIfIndex(uint32_t interface)
 {
-	m_interface = interface;
+  m_interface = interface;
 }
 
 void
 Hwmp::DisablePort(uint32_t port)
 {
-	int position = 0;
-	for(std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
-	{
-		if((*i)->GetAssociatedIfaceId() == port)
-		{
-			m_states[position] = DISABLED;
-			m_hwmpStates[position]->Disable();
-			return;
-		}
-		position ++;
-	}
+  int position = 0;
+  for (std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i != m_hwmpStates.end(); i++)
+    {
+      if ((*i)->GetAssociatedIfaceId() == port)
+        {
+          m_states[position] = DISABLED;
+          m_hwmpStates[position]->Disable();
+          return;
+        }
+      position ++;
+    }
 }
 
 void
 Hwmp::EnablePort(uint32_t port)
 {
-	int position = 0;
-	for(std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
-	{
-		if((*i)->GetAssociatedIfaceId() == port)
-		{
-			m_states[position] = ENABLED;
-			m_hwmpStates[position]->Enable();
-			return;
-		}
-		position ++;
-	}
+  int position = 0;
+  for (std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
+    {
+      if ((*i)->GetAssociatedIfaceId() == port)
+        {
+          m_states[position] = ENABLED;
+          m_hwmpStates[position]->Enable();
+          return;
+        }
+      position ++;
+    }
 }
 
 void
 Hwmp::SetRoot(uint32_t port)
 {
-	int position = 0;
-	for(std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
-	{
-		if(((*i)->GetAssociatedIfaceId() == port)||(port == HwmpRtable::PORT_ANY))
-		{
-			if(m_hwmpStates[position]->SetRoot())
-			{
-				m_modes[position] = ROOT;
-				NS_LOG_DEBUG("I am proactive");
-			}
-		}
-		position ++;
-	}
+  int position = 0;
+  for (std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
+    {
+      if (((*i)->GetAssociatedIfaceId() == port)||(port == HwmpRtable::PORT_ANY))
+        {
+          if (m_hwmpStates[position]->SetRoot())
+            {
+              m_modes[position] = ROOT;
+              NS_LOG_DEBUG("I am proactive");
+            }
+        }
+      position ++;
+    }
 }
 void
 Hwmp::SetProactive(uint32_t port)
 {
-	int position = 0;
-	for(std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
-	{
-		if((*i)->GetAssociatedIfaceId() == port)
-		{
-			m_modes[position] = PROACTIVE;
-			return;
-		}
-		position ++;
-	}
+  int position = 0;
+  for (std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
+    {
+      if ((*i)->GetAssociatedIfaceId() == port)
+        {
+          m_modes[position] = PROACTIVE;
+          return;
+        }
+      position ++;
+    }
 }
 bool
 Hwmp::IsRoot(uint32_t port)
 {
-	int position = 0;
-	for(std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
-	{
-		if((*i)->GetAssociatedIfaceId() == port)
-			if(m_modes[position] == ROOT)
-				return true;
-		position ++;
-	}
-	return false;
+  int position = 0;
+  for (std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
+    {
+      if ((*i)->GetAssociatedIfaceId() == port)
+        if (m_modes[position] == ROOT)
+          return true;
+      position ++;
+    }
+  return false;
 }
 void
 Hwmp::UnSetRoot(uint32_t port)
 {
-	int position = 0;
-	for(std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
-	{
-		if(((*i)->GetAssociatedIfaceId() == port)||(port == HwmpRtable::PORT_ANY))
-		{
-			m_modes[position] = REACTIVE;
-			m_hwmpStates[position]->UnSetRoot();
-		}
-		position ++;
-	}
+  int position = 0;
+  for (std::vector<Ptr<HwmpState> >::iterator i = m_hwmpStates.begin(); i!= m_hwmpStates.end(); i++)
+    {
+      if (((*i)->GetAssociatedIfaceId() == port)||(port == HwmpRtable::PORT_ANY))
+        {
+          m_modes[position] = REACTIVE;
+          m_hwmpStates[position]->UnSetRoot();
+        }
+      position ++;
+    }
 }
 
 void
 Hwmp::ObtainRoutingInformation(
-		HwmpState::INFO info
-				)
+  HwmpState::INFO info
+)
 {
-	switch(info.type)
-	{
-	case HwmpState::INFO_PREP:
-		if(info.me != info.source)
-		{
-			m_rtable->AddPrecursor(info.source, info.outPort, info.nextHop);
-			m_rtable->AddPrecursor(info.destination, info.outPort, info.prevHop);
-			NS_LOG_DEBUG("path to "<<info.source<<" precursor is "<<info.nextHop);
-			NS_LOG_DEBUG("path to "<<info.destination<<" precursor is "<<info.prevHop);
-		}
-	case HwmpState::INFO_PREQ:
-		m_rtable->AddReactivePath(
-				info.destination,
-				info.nextHop,
-				info.outPort,
-				info.metric,
-				info.lifetime,
-				info.dsn);
-		SendAllPossiblePackets(info.destination);
-		break;
-	case HwmpState::INFO_PERR:
-		//delete first subentry
-	case HwmpState::INFO_PROACTIVE:
-		//add information to the root MP.
-			m_rtable->AddProactivePath(
-			info.metric,
-			info.destination,
-			info.nextHop,
-			info.outPort,
-			info.lifetime,
-			info.dsn);
-			//Set mode as PROACTIVE:
-			SetProactive(info.outPort);
-		break;
-	case HwmpState::INFO_NEW_PEER:
+  switch (info.type)
+    {
+    case HwmpState::INFO_PREP:
+      if (info.me != info.source)
+        {
+          m_rtable->AddPrecursor(info.source, info.outPort, info.nextHop);
+          m_rtable->AddPrecursor(info.destination, info.outPort, info.prevHop);
+          NS_LOG_DEBUG("path to "<<info.source<<" precursor is "<<info.nextHop);
+          NS_LOG_DEBUG("path to "<<info.destination<<" precursor is "<<info.prevHop);
+        }
+    case HwmpState::INFO_PREQ:
+      m_rtable->AddReactivePath(
+        info.destination,
+        info.nextHop,
+        info.outPort,
+        info.metric,
+        info.lifetime,
+        info.dsn);
+      SendAllPossiblePackets(info.destination);
+      break;
+    case HwmpState::INFO_PERR:
+      //delete first subentry
+    case HwmpState::INFO_PROACTIVE:
+      //add information to the root MP.
+      m_rtable->AddProactivePath(
+        info.metric,
+        info.destination,
+        info.nextHop,
+        info.outPort,
+        info.lifetime,
+        info.dsn);
+      //Set mode as PROACTIVE:
+      SetProactive(info.outPort);
+      break;
+    case HwmpState::INFO_NEW_PEER:
 #if 0
-			m_rtable->AddReactivePath(
-				info.destination,
-				info.nextHop,
-				info.outPort,
-				info.metric,
-				Seconds(0),
-				0);
+      m_rtable->AddReactivePath(
+        info.destination,
+        info.nextHop,
+        info.outPort,
+        info.metric,
+        Seconds(0),
+        0);
 #endif
-		break;
-	case HwmpState::INFO_FAILED_PEER:
-		/**
-		 * Conditions for generating PERR
-		 */
-		{
-			NS_LOG_DEBUG("Failed peer"<<info.destination);
-			std::vector<HwmpRtable::FailedDestination> failedDestinations = 
-				m_rtable->GetUnreachableDestinations(info.destination, info.outPort);
-			/**
-			 * Entry about peer does not contain seqnum
-			 */
-			HwmpRtable::FailedDestination peer;
-			peer.destination = info.destination;
-			peer.seqnum = 0;
-			failedDestinations.push_back(peer);
-			StartPathErrorProcedure(failedDestinations, info.outPort);
-		}
-		break;
-	default:
-		return;
-	}
+      break;
+    case HwmpState::INFO_FAILED_PEER:
+      /**
+       * Conditions for generating PERR
+       */
+    {
+      NS_LOG_DEBUG("Failed peer"<<info.destination);
+      std::vector<HwmpRtable::FailedDestination> failedDestinations =
+        m_rtable->GetUnreachableDestinations(info.destination, info.outPort);
+      /**
+       * Entry about peer does not contain seqnum
+       */
+      HwmpRtable::FailedDestination peer;
+      peer.destination = info.destination;
+      peer.seqnum = 0;
+      failedDestinations.push_back(peer);
+      StartPathErrorProcedure(failedDestinations, info.outPort);
+    }
+    break;
+    default:
+      return;
+    }
 }
 
 HwmpRtable::LookupResult
 Hwmp::RequestRouteForAddress(const Mac48Address& dst)
 {
-	return m_rtable->LookupReactive(dst);
+  return m_rtable->LookupReactive(dst);
 }
 
 HwmpRtable::LookupResult
 Hwmp::RequestRootPathForPort(uint32_t port)
 {
-	return m_rtable->LookupProactive(port);
+  return m_rtable->LookupProactive(port);
 }
 
 void
 Hwmp::StartPathErrorProcedure(std::vector<HwmpRtable::FailedDestination> destinations, uint32_t port)
 {
-	NS_LOG_DEBUG("START PERR");
-	for(unsigned int i  = 0; i < m_hwmpStates.size(); i++)
-		if(m_hwmpStates[i]->GetAssociatedIfaceId() == port)
-			m_pathErrorCallback[i](destinations);
+  NS_LOG_DEBUG("START PERR");
+  for (unsigned int i  = 0; i < m_hwmpStates.size(); i++)
+    if (m_hwmpStates[i]->GetAssociatedIfaceId() == port)
+      m_pathErrorCallback[i](destinations);
 }
 std::vector<Mac48Address>
 Hwmp::GetRetransmittersForFailedDestinations(std::vector<HwmpRtable::FailedDestination> failedDest, uint32_t port)
 {
-	std::vector<Mac48Address> retransmitters;
-	if(m_broadcastPerr)
-		retransmitters.push_back(Mac48Address::GetBroadcast());
-	else
-		for(unsigned int i = 0; i< failedDest.size(); i ++)
-		{
-			std::vector<Mac48Address> precursors = 
-				m_rtable->GetPrecursors(failedDest[i].destination, port);
-			for(unsigned int j = 0; j < precursors.size(); j++)
-			{
-				for(unsigned int k = 0; k < retransmitters.size(); k ++)
-					if(retransmitters[k] == precursors[j])
-						break;
-				retransmitters.push_back(precursors[j]);
-			}
-		}
-	for(unsigned int i = 0; i < failedDest.size(); i ++)
-	{
-		m_rtable->DeleteReactivePath(failedDest[i].destination, port);
-		m_rtable->DeleteProactivePath(failedDest[i].destination, port);
-	}
-	return retransmitters;
+  std::vector<Mac48Address> retransmitters;
+  if (m_broadcastPerr)
+    retransmitters.push_back(Mac48Address::GetBroadcast());
+  else
+    for (unsigned int i = 0; i < failedDest.size(); i ++)
+      {
+        std::vector<Mac48Address> precursors =
+          m_rtable->GetPrecursors(failedDest[i].destination, port);
+        for (unsigned int j = 0; j < precursors.size(); j++)
+          {
+            for (unsigned int k = 0; k < retransmitters.size(); k ++)
+              if (retransmitters[k] == precursors[j])
+                break;
+            retransmitters.push_back(precursors[j]);
+          }
+      }
+  for (unsigned int i = 0; i < failedDest.size(); i ++)
+    {
+      m_rtable->DeleteReactivePath(failedDest[i].destination, port);
+      m_rtable->DeleteProactivePath(failedDest[i].destination, port);
+    }
+  return retransmitters;
 }
 void
 Hwmp::SetMaxQueueSize(int maxPacketsPerDestination)
 {
-	m_maxQueueSize = maxPacketsPerDestination;
+  m_maxQueueSize = maxPacketsPerDestination;
 }
 
 bool
 Hwmp::QueuePacket(L2RoutingProtocol::QueuedPacket packet)
 {
-	if((int)m_rqueue[packet.dst].size() > m_maxQueueSize)
-		return false;
-	m_rqueue[packet.dst].push(packet);
-	return true;
+  if ((int)m_rqueue[packet.dst].size() > m_maxQueueSize)
+    return false;
+  m_rqueue[packet.dst].push(packet);
+  return true;
 }
 
 L2RoutingProtocol::QueuedPacket
 Hwmp::DequeuePacket(Mac48Address dst)
 {
-	L2RoutingProtocol::QueuedPacket retval;
-	retval.pkt = NULL;
-	//Ptr<Packet> in this structure is NULL when queue is empty
-	std::map<Mac48Address, std::queue<QueuedPacket>, mac48addrComparator>:: iterator i = m_rqueue.find(dst);
-	if(i == m_rqueue.end())
-		return retval;
-	if((int)m_rqueue[dst].size() == 0)
-		return retval;
-	if((int)i->second.size() == 0)
-	{
-		m_rqueue.erase(i);
-		return retval;
-	}
-	retval = m_rqueue[dst].front();
-	m_rqueue[dst].pop();
-	return retval;
+  L2RoutingProtocol::QueuedPacket retval;
+  retval.pkt = NULL;
+  //Ptr<Packet> in this structure is NULL when queue is empty
+  std::map<Mac48Address, std::queue<QueuedPacket>, mac48addrComparator>:: iterator i = m_rqueue.find(dst);
+  if (i == m_rqueue.end())
+    return retval;
+  if ((int)m_rqueue[dst].size() == 0)
+    return retval;
+  if ((int)i->second.size() == 0)
+    {
+      m_rqueue.erase(i);
+      return retval;
+    }
+  retval = m_rqueue[dst].front();
+  m_rqueue[dst].pop();
+  return retval;
 }
 
 void
 Hwmp::SendAllPossiblePackets(Mac48Address dst)
 {
-	HwmpRtable::LookupResult result = m_rtable->LookupReactive(dst);
-	L2RoutingProtocol::QueuedPacket packet;
-		while(1)
-		       
-		{
-			packet = DequeuePacket(dst);
-			if(packet.pkt == NULL)
-			return;
-			//set RA tag for retransmitter:
-			HwmpTag tag;
-			NS_ASSERT(packet.pkt->FindFirstMatchingTag(tag));
-			tag.SetAddress(result.retransmitter);
-			NS_ASSERT(result.retransmitter!=Mac48Address::GetBroadcast());
-			packet.pkt->RemoveAllTags();
-			packet.pkt->AddTag(tag);
-			packet.reply(true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
-		}
+  HwmpRtable::LookupResult result = m_rtable->LookupReactive(dst);
+  L2RoutingProtocol::QueuedPacket packet;
+  while (1)
+
+    {
+      packet = DequeuePacket(dst);
+      if (packet.pkt == NULL)
+        return;
+      //set RA tag for retransmitter:
+      HwmpTag tag;
+      NS_ASSERT(packet.pkt->FindFirstMatchingTag(tag));
+      tag.SetAddress(result.retransmitter);
+      NS_ASSERT(result.retransmitter!=Mac48Address::GetBroadcast());
+      packet.pkt->RemoveAllTags();
+      packet.pkt->AddTag(tag);
+      packet.reply(true, packet.pkt, packet.src, packet.dst, packet.protocol, result.ifIndex);
+    }
 }
 
 bool
 Hwmp::ShouldSendPreq(Mac48Address dst)
 {
-	std::map<Mac48Address, EventId, mac48addrComparator>::iterator i = m_timeoutDatabase.find(dst);
-	if(i == m_timeoutDatabase.end())
-	{
-		m_timeoutDatabase[dst] = Simulator::Schedule(
-				MilliSeconds(2*(dot11sParameters::dot11MeshHWMPnetDiameterTraversalTime.GetMilliSeconds())),
-				&Hwmp::RetryPathDiscovery, this, dst, 0);
-		return true;
-	}
-	return false;
+  std::map<Mac48Address, EventId, mac48addrComparator>::iterator i = m_timeoutDatabase.find(dst);
+  if (i == m_timeoutDatabase.end())
+    {
+      m_timeoutDatabase[dst] = Simulator::Schedule(
+                                 MilliSeconds(2*(dot11sParameters::dot11MeshHWMPnetDiameterTraversalTime.GetMilliSeconds())),
+                                 &Hwmp::RetryPathDiscovery, this, dst, 0);
+      return true;
+    }
+  return false;
 }
 void
 Hwmp::RetryPathDiscovery(Mac48Address dst, uint8_t numOfRetry)
 {
-	HwmpRtable::LookupResult result = m_rtable->LookupReactive(dst);
-	if(result.retransmitter != Mac48Address::GetBroadcast())
-	{
-		std::map<Mac48Address, EventId, mac48addrComparator>::iterator i = m_timeoutDatabase.find(dst);
-		NS_ASSERT(i!=  m_timeoutDatabase.end());
-		m_timeoutDatabase.erase(i);
-		return;
-	}
-	numOfRetry++;
-	if(numOfRetry > dot11sParameters::dot11MeshHWMPmaxPREQretries)
-	{
-		L2RoutingProtocol::QueuedPacket packet;
-		//purge queue and delete entry from retryDatabase
-		while(1)
-		{
-			packet = DequeuePacket(dst);
-			if(packet.pkt == NULL)
-				break;
-			packet.reply(false, packet.pkt, packet.src, packet.dst, packet.protocol, HwmpRtable::MAX_METRIC);
-		}
-		std::map<Mac48Address, EventId, mac48addrComparator>::iterator i = m_timeoutDatabase.find(dst);
-		NS_ASSERT(i!=  m_timeoutDatabase.end());
-		m_timeoutDatabase.erase(i);
-		return;
-	}
-	for(unsigned int i = 0; i< m_requestCallback.size(); i++)
-		if((m_modes[i] == REACTIVE) || (m_modes[i] == ROOT))
-				m_requestCallback[i](dst);
-	m_timeoutDatabase[dst] = Simulator::Schedule(
-			MilliSeconds(2*(dot11sParameters::dot11MeshHWMPnetDiameterTraversalTime.GetMilliSeconds())),
-			&Hwmp::RetryPathDiscovery, this, dst, numOfRetry);
+  HwmpRtable::LookupResult result = m_rtable->LookupReactive(dst);
+  if (result.retransmitter != Mac48Address::GetBroadcast())
+    {
+      std::map<Mac48Address, EventId, mac48addrComparator>::iterator i = m_timeoutDatabase.find(dst);
+      NS_ASSERT(i !=  m_timeoutDatabase.end());
+      m_timeoutDatabase.erase(i);
+      return;
+    }
+  numOfRetry++;
+  if (numOfRetry > dot11sParameters::dot11MeshHWMPmaxPREQretries)
+    {
+      L2RoutingProtocol::QueuedPacket packet;
+      //purge queue and delete entry from retryDatabase
+      while (1)
+        {
+          packet = DequeuePacket(dst);
+          if (packet.pkt == NULL)
+            break;
+          packet.reply(false, packet.pkt, packet.src, packet.dst, packet.protocol, HwmpRtable::MAX_METRIC);
+        }
+      std::map<Mac48Address, EventId, mac48addrComparator>::iterator i = m_timeoutDatabase.find(dst);
+      NS_ASSERT(i !=  m_timeoutDatabase.end());
+      m_timeoutDatabase.erase(i);
+      return;
+    }
+  for (unsigned int i = 0; i < m_requestCallback.size(); i++)
+    if ((m_modes[i] == REACTIVE) || (m_modes[i] == ROOT))
+      m_requestCallback[i](dst);
+  m_timeoutDatabase[dst] = Simulator::Schedule(
+                             MilliSeconds(2*(dot11sParameters::dot11MeshHWMPnetDiameterTraversalTime.GetMilliSeconds())),
+                             &Hwmp::RetryPathDiscovery, this, dst, numOfRetry);
 }
 } //namespace ns3
diff --git a/src/devices/l2-routing/l2-routing-hwmp/hwmp.h b/src/devices/l2-routing/l2-routing-hwmp/hwmp.h
index e3e3888e8..be12fc7c7 100644
--- a/src/devices/l2-routing/l2-routing-hwmp/hwmp.h
+++ b/src/devices/l2-routing/l2-routing-hwmp/hwmp.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -33,265 +33,254 @@
 #include "ns3/ptr.h"
 #include "hwmp-state.h"
 namespace ns3 {
-	class HwmpState;
-	/**
-	 * \ingroup mesh
-	 * 
-	 * \brief Hwmp tag implements interaction between HWMP
-	 * protocol and MeshWifiMac
-	 * 
-	 * \details Hwmp tag keeps the following:
-	 * 1. When packet is passed from Hwmp to 11sMAC:
-	 * 	- retransmitter address,
-	 * 	- TTL value,
-	 * 2. When packet is passed to Hwmp from 11sMAC:
-	 * 	- lasthop address,
-	 * 	- TTL value,
-	 * 	- metric value (metric of link is recalculated
-	 * 	at each packet, but routing table stores metric
-	 * 	obtained during path discovery procedure)
-	 */
-	class HwmpTag : public Tag
-	{
-		public:
-			HwmpTag();
-			~HwmpTag();
-			void		SetAddress(Mac48Address retransmitter);
-			Mac48Address	GetAddress();
-			void		SetTtl(uint8_t ttl);
-			uint8_t	GetTtl();
-			void		SetMetric(uint32_t metric);
-			uint32_t	GetMetric();
-			void		SetSeqno(uint32_t seqno);
-			uint32_t	GetSeqno();
-			void		DecrementTtl();
+class HwmpState;
+/**
+ * \ingroup mesh
+ *
+ * \brief Hwmp tag implements interaction between HWMP
+ * protocol and MeshWifiMac
+ *
+ * \details Hwmp tag keeps the following:
+ * 1. When packet is passed from Hwmp to 11sMAC:
+ *  - retransmitter address,
+ *  - TTL value,
+ * 2. When packet is passed to Hwmp from 11sMAC:
+ *  - lasthop address,
+ *  - TTL value,
+ *  - metric value (metric of link is recalculated
+ *  at each packet, but routing table stores metric
+ *  obtained during path discovery procedure)
+ */
+class HwmpTag : public Tag
+{
+public:
+  HwmpTag();
+  ~HwmpTag();
+  void  SetAddress(Mac48Address retransmitter);
+  Mac48Address GetAddress();
+  void  SetTtl(uint8_t ttl);
+  uint8_t GetTtl();
+  void  SetMetric(uint32_t metric);
+  uint32_t GetMetric();
+  void  SetSeqno(uint32_t seqno);
+  uint32_t GetSeqno();
+  void  DecrementTtl();
 
-			static TypeId		GetTypeId ();
-			virtual TypeId		GetInstanceTypeId () const;
-			virtual uint32_t	GetSerializedSize () const;
-			virtual void		Serialize (TagBuffer i) const;
-			virtual void		Deserialize (TagBuffer i);
-			virtual void		Print (std::ostream &os) const;
-		private:
-			Mac48Address	m_address;
-			uint8_t		m_ttl;
-			uint32_t	m_metric;
-			uint32_t	m_seqno;
-	};
-	/**
-	 * \ingroup mesh
-	 */
-	class Hwmp : public L2RoutingProtocol
-	{
-		public:
-			static TypeId GetTypeId();
-			Hwmp();
-			~Hwmp();
-			void	DoDispose();
-			//intheritedfrom L2RoutingProtocol
-			/**
-			 * \brief L2Routing protocol base class metod
-			 *
-			 * \details Route resolving procedure consits
-			 * of the following steps:
-			 * 1. Find reactive route and send a packet.
-			 * 2. Find all ports which are operate in
-			 * 'Proactive' mode and find a proper default
-			 * routes. and send packet to all proactive
-			 * 'ports'.
-			 * 3. If there are ports which are operate in
-			 * reactive mode - queue packet and start
-			 * route reactive path discovery
-			 *
-			 * \bug Now packet is sent to the 'best root'
-			 * rather than to the best root at each port
-			 */
-			bool	RequestRoute(
-					uint32_t		sourceIface,
-					const Mac48Address	source,
-					const Mac48Address	destination,
-					Ptr<Packet>		packet,
-					uint16_t		protocolType,
-					L2RoutingProtocol::RouteReplyCallback
-					routeReply
-					);
-			bool	AttachPorts(std::vector<Ptr<NetDevice> >);
-			void	SetIfIndex(uint32_t interface);
-			/**
-			 * \brief Disables port by index.
-			 * \details Needed for external modules like
-			 * clusterization.
-			 */
-			void	DisablePort(uint32_t port);
-			/**
-			 * \brief enables port
-			 */
-			void	EnablePort(uint32_t port);
-			/**
-			 * \brief Setting proative mode.
-			 * \details To enable proactive mode you must
-			 * set a root node. Choosing the route is made
-			 * in accordance with the following: 
-			 * 	1. Find 'reactive' route. If route is
-			 * 	found - send a packet using this
-			 * 	information
-			 * 	2. If there is no reactive route -
-			 * 	find proactive or 'default' route.
-			 * \attention Comparsion between proactive and
-			 * reactive routes is incorrect, because we
-			 * have metric to root MP in te first case and
-			 * metric to the destination in the second
-			 * case.
-			 * \param port is the port where proactive
-			 * mode should be activated
-			 */
-			void	SetRoot(uint32_t port);
-			/**
-			 * \brief Disable root functionality at a
-			 * given port
-			 */
-			void	UnSetRoot(uint32_t port);
-			/**
-			 * \brief HwmpState retrns to Hwmp class all
-			 * routing information obtained from all HWMP
-			 * action frames
-			 */
-			void	ObtainRoutingInformation(
-					HwmpState::INFO info
-					);
-			/**
-			 * \brief Hwmp state noyifyes that neighbour
-			 * is dissapeared. Hwmp state knows about peer
-			 * failure from MAC
-			 */
-			void	PeerFailure(Mac48Address peerAddress);
-			void	SetMaxTtl(uint8_t ttl);
-			uint8_t
-				GetMaxTtl();
-		private:
-			static const uint32_t MAX_SEQNO = 0xffffffff;
-			//candidate queue is implemented inside the
-			//protocol:
-			void		SetMaxQueueSize(int maxPacketsPerDestination);
-			int		m_maxQueueSize;
-			bool		QueuePacket(L2RoutingProtocol::QueuedPacket packet);
-			L2RoutingProtocol::QueuedPacket
-					DequeuePacket(Mac48Address dst);
-			void		SendAllPossiblePackets(Mac48Address dst);
-			std::map<Mac48Address, std::queue<QueuedPacket> > 
-					m_rqueue;
-			//devices and HWMP states:
-			enum DeviceState {
-				ENABLED,
-				DISABLED
-			};
-			enum DeviceMode {
-				REACTIVE,
-				PROACTIVE,
-				ROOT
-			};
-			std::vector<enum DeviceState>
-					m_states;
-			std::vector<enum DeviceMode>
-					m_modes;
-			std::vector<Ptr<HwmpState> >
-					m_hwmpStates;
-			//Routing table:
-			Ptr<HwmpRtable>
-					m_rtable;
-			//Proactive routines:
-			/**
-			 * \brief Set port state as proactive.
-			 * \details mode is supposed to be proactive
-			 * when proatcive PREQ with a valid
-			 * information was received.
-			 */
-			void		SetProactive(uint32_t port);
-			/**
-			 * \brief Checks if the port is root, if true
-			 * - no default routes must be used at this
-			 * port
-			 */
-			bool		IsRoot(uint32_t port);
-			/**
-			 * \brief Interaction with HwmpState class -
-			 * request for starting routing discover
-			 * procedure (reactive route discovery!)
-			 * \param Mac48Address is destination to be
-			 * resolved
-			 */
-			std::vector< Callback<void, Mac48Address> >
-					m_requestCallback;
-			/**
-			 * \brief Callback that shall be executed when
-			 * need to send Path error
-			 * \param std::vector<Mac48Address> is the
-			 * list of unreachable destinations
-			 * \param std::vector<Mac48Address> is
-			 * receivers of PERR
-			 */
-			std::vector<Callback<void,std::vector<HwmpRtable::FailedDestination> > >
-					m_pathErrorCallback;
-			void	StartPathErrorProcedure(
-					std::vector<HwmpRtable::FailedDestination> destinations,
-					uint32_t port);
-			/**
-			 * \brief HwmpState need to know where to
-			 * retransmit PERR, only HWMP knows how to
-			 * retransmit it (broadcast/unicast) and only
-			 * HWMP has accessto routing table
-			 */
-			std::vector<Mac48Address>
-					GetRetransmittersForFailedDestinations(
-							std::vector<HwmpRtable::FailedDestination> failedDest,
-							uint32_t port);
-			/**
-			 * \brief Needed by HwmpState to find routes in case
-			 * of intermediate reply and choosing the
-			 * better route
-			 * 
-			 */
-			HwmpRtable::LookupResult
-					RequestRouteForAddress(const Mac48Address& destination);
-			HwmpRtable::LookupResult
-					RequestRootPathForPort(uint32_t port);
+  static  TypeId  GetTypeId ();
+  virtual TypeId  GetInstanceTypeId () const;
+  virtual uint32_t GetSerializedSize () const;
+  virtual void  Serialize (TagBuffer i) const;
+  virtual void  Deserialize (TagBuffer i);
+  virtual void  Print (std::ostream &os) const;
+private:
+  Mac48Address m_address;
+  uint8_t  m_ttl;
+  uint32_t m_metric;
+  uint32_t m_seqno;
+};
+/**
+ * \ingroup mesh
+ */
+class Hwmp : public L2RoutingProtocol
+{
+public:
+  static TypeId GetTypeId();
+  Hwmp();
+  ~Hwmp();
+  void DoDispose();
+  //intheritedfrom L2RoutingProtocol
+  /**
+   * \brief L2Routing protocol base class metod
+   *
+   * \details Route resolving procedure consits
+   * of the following steps:
+   * 1. Find reactive route and send a packet.
+   * 2. Find all ports which are operate in
+   * 'Proactive' mode and find a proper default
+   * routes. and send packet to all proactive
+   * 'ports'.
+   * 3. If there are ports which are operate in
+   * reactive mode - queue packet and start
+   * route reactive path discovery
+   *
+   * \bug Now packet is sent to the 'best root'
+   * rather than to the best root at each port
+   */
+  bool RequestRoute(
+    uint32_t  sourceIface,
+    const Mac48Address source,
+    const Mac48Address destination,
+    Ptr<Packet>  packet,
+    uint16_t  protocolType,
+    L2RoutingProtocol::RouteReplyCallback  routeReply
+  );
+  bool AttachPorts(std::vector<Ptr<NetDevice> >);
+  void SetIfIndex(uint32_t interface);
+  /**
+   * \brief Disables port by index.
+   * \details Needed for external modules like
+   * clusterization.
+   */
+  void DisablePort(uint32_t port);
+  /**
+   * \brief enables port
+   */
+  void EnablePort(uint32_t port);
+  /**
+   * \brief Setting proative mode.
+   * \details To enable proactive mode you must
+   * set a root node. Choosing the route is made
+   * in accordance with the following:
+   *  1. Find 'reactive' route. If route is
+   *  found - send a packet using this
+   *  information
+   *  2. If there is no reactive route -
+   *  find proactive or 'default' route.
+   * \attention Comparsion between proactive and
+   * reactive routes is incorrect, because we
+   * have metric to root MP in te first case and
+   * metric to the destination in the second
+   * case.
+   * \param port is the port where proactive
+   * mode should be activated
+   */
+  void SetRoot(uint32_t port);
+  /**
+   * \brief Disable root functionality at a
+   * given port
+   */
+  void UnSetRoot(uint32_t port);
+  /**
+   * \brief HwmpState retrns to Hwmp class all
+   * routing information obtained from all HWMP
+   * action frames
+   */
+  void ObtainRoutingInformation(
+    HwmpState::INFO info
+  );
+  /**
+   * \brief Hwmp state noyifyes that neighbour
+   * is dissapeared. Hwmp state knows about peer
+   * failure from MAC
+   */
+  void PeerFailure(Mac48Address peerAddress);
+  void SetMaxTtl(uint8_t ttl);
+  uint8_t  GetMaxTtl();
+private:
+  static const uint32_t MAX_SEQNO = 0xffffffff;
+  //candidate queue is implemented inside the
+  //protocol:
+  void  SetMaxQueueSize(int maxPacketsPerDestination);
+  int  m_maxQueueSize;
+  bool  QueuePacket(L2RoutingProtocol::QueuedPacket packet);
+  L2RoutingProtocol::QueuedPacket  DequeuePacket(Mac48Address dst);
+  void  SendAllPossiblePackets(Mac48Address dst);
+  std::map<Mac48Address, std::queue<QueuedPacket> >  m_rqueue;
+  //devices and HWMP states:
+  enum DeviceState {
+    ENABLED,
+    DISABLED
+  };
+  enum DeviceMode {
+    REACTIVE,
+    PROACTIVE,
+    ROOT
+  };
+  std::vector<enum DeviceState>  m_states;
+  std::vector<enum DeviceMode>   m_modes;
+  std::vector<Ptr<HwmpState> >   m_hwmpStates;
+  //Routing table:
+  Ptr<HwmpRtable>  m_rtable;
+  //Proactive routines:
+  /**
+   * \brief Set port state as proactive.
+   * \details mode is supposed to be proactive
+   * when proatcive PREQ with a valid
+   * information was received.
+   */
+  void  SetProactive(uint32_t port);
+  /**
+   * \brief Checks if the port is root, if true
+   * - no default routes must be used at this
+   * port
+   */
+  bool  IsRoot(uint32_t port);
+  /**
+   * \brief Interaction with HwmpState class -
+   * request for starting routing discover
+   * procedure (reactive route discovery!)
+   * \param Mac48Address is destination to be
+   * resolved
+   */
+  std::vector< Callback<void, Mac48Address> >  m_requestCallback;
+  /**
+   * \brief Callback that shall be executed when
+   * need to send Path error
+   * \param std::vector<Mac48Address> is the
+   * list of unreachable destinations
+   * \param std::vector<Mac48Address> is
+   * receivers of PERR
+   */
+  std::vector<Callback<void,std::vector<HwmpRtable::FailedDestination> > >
+  m_pathErrorCallback;
+  void StartPathErrorProcedure(
+    std::vector<HwmpRtable::FailedDestination> destinations,
+    uint32_t port);
+  /**
+   * \brief HwmpState need to know where to
+   * retransmit PERR, only HWMP knows how to
+   * retransmit it (broadcast/unicast) and only
+   * HWMP has accessto routing table
+   */
+  std::vector<Mac48Address>
+  GetRetransmittersForFailedDestinations(
+    std::vector<HwmpRtable::FailedDestination> failedDest,
+    uint32_t port);
+  /**
+   * \brief Needed by HwmpState to find routes in case
+   * of intermediate reply and choosing the
+   * better route
+   *
+   */
+  HwmpRtable::LookupResult  RequestRouteForAddress(const Mac48Address& destination);
+  HwmpRtable::LookupResult  RequestRootPathForPort(uint32_t port);
 
-			/**
-			 * \brief interface which is the HWMP attached to
-			 * (Virtual netdevice)
-			 */
-			uint32_t	m_interface;
-			/**
-			 * \attention mesh seqno is processed at HWMP
-			 */
-			uint32_t	m_seqno;
-			std::map<Mac48Address, uint32_t, mac48addrComparator>
-					m_seqnoDatabase;
-			//Timers:
-			/**
-			 * /brief checks when last preq was initiated, returns
-			 * false when retry has not expired
-			 */
-			bool		ShouldSendPreq(Mac48Address dst);
-			/**
-			 * \brief Generates PREQ retry when route is
-			 * still unresolved after first PREQ
-			 * If number of retries greater than
-			 * dot11sParameters::dot11MeshHWMPmaxPREQretries,
-			 * we return all packets to upper layers
-			 */
-			void		RetryPathDiscovery(Mac48Address dst, uint8_t numOfRetry);
-			/**
-			 * Keeps PREQ retry timers for every
-			 * destination
-			 */
-			std::map<Mac48Address, EventId, mac48addrComparator>
-					m_timeoutDatabase;
-			/**
-			 * Configurable parameters:
-			 */
-			uint8_t		m_maxTtl;
-			bool		m_broadcastPerr;
-	};
+  /**
+   * \brief interface which is the HWMP attached to
+   * (Virtual netdevice)
+   */
+  uint32_t m_interface;
+  /**
+   * \attention mesh seqno is processed at HWMP
+   */
+  uint32_t m_seqno;
+  std::map<Mac48Address, uint32_t, mac48addrComparator>
+  m_seqnoDatabase;
+  //Timers:
+  /**
+   * /brief checks when last preq was initiated, returns
+   * false when retry has not expired
+   */
+  bool  ShouldSendPreq(Mac48Address dst);
+  /**
+   * \brief Generates PREQ retry when route is
+   * still unresolved after first PREQ
+   * If number of retries greater than
+   * dot11sParameters::dot11MeshHWMPmaxPREQretries,
+   * we return all packets to upper layers
+   */
+  void  RetryPathDiscovery(Mac48Address dst, uint8_t numOfRetry);
+  /**
+   * Keeps PREQ retry timers for every
+   * destination
+   */
+  std::map<Mac48Address, EventId, mac48addrComparator>
+  m_timeoutDatabase;
+  /**
+   * Configurable parameters:
+   */
+  uint8_t  m_maxTtl;
+  bool     m_broadcastPerr;
+};
 } //namespace ns3
 #endif
diff --git a/src/devices/l2-routing/l2-routing-main/l2-routing-net-device.cc b/src/devices/l2-routing/l2-routing-main/l2-routing-net-device.cc
index 26b28653c..ca43dde16 100644
--- a/src/devices/l2-routing/l2-routing-main/l2-routing-net-device.cc
+++ b/src/devices/l2-routing/l2-routing-main/l2-routing-net-device.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -37,319 +37,319 @@ NS_OBJECT_ENSURE_REGISTERED (L2RoutingNetDevice);
 TypeId
 L2RoutingNetDevice::GetTypeId ()
 {
-	static TypeId tid = TypeId ("ns3::L2RoutingNetDevice")
-		.SetParent<NetDevice> ()
-		.AddConstructor<L2RoutingNetDevice> ()
-		;
-	return tid;
+  static TypeId tid = TypeId ("ns3::L2RoutingNetDevice")
+                      .SetParent<NetDevice> ()
+                      .AddConstructor<L2RoutingNetDevice> ()
+                      ;
+  return tid;
 }
 
 
 L2RoutingNetDevice::L2RoutingNetDevice ()
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	m_channel = CreateObject<BridgeChannel> ();
+  NS_LOG_FUNCTION_NOARGS ();
+  m_channel = CreateObject<BridgeChannel> ();
 }
 
 L2RoutingNetDevice::~L2RoutingNetDevice()
 {
-	NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_FUNCTION_NOARGS ();
 }
 
-	void
+void
 L2RoutingNetDevice::DoDispose ()
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	for (std::vector< Ptr<NetDevice> >::iterator iter = m_ports.begin (); iter != m_ports.end (); iter++)
-		*iter = 0;
-	m_ports.clear ();
-	m_node = 0;
-	NetDevice::DoDispose ();
+  NS_LOG_FUNCTION_NOARGS ();
+  for (std::vector< Ptr<NetDevice> >::iterator iter = m_ports.begin (); iter != m_ports.end (); iter++)
+    *iter = 0;
+  m_ports.clear ();
+  m_node = 0;
+  NetDevice::DoDispose ();
 
 }
 
-	void
+void
 L2RoutingNetDevice::ReceiveFromDevice (Ptr<NetDevice> incomingPort, Ptr<const Packet> packet, uint16_t protocol,
-		Address const &src, Address const &dst, PacketType packetType)
+                                       Address const &src, Address const &dst, PacketType packetType)
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	NS_LOG_DEBUG ("UID is " << packet->GetUid ());
-	const Mac48Address src48 = Mac48Address::ConvertFrom (src);
-	const Mac48Address dst48 = Mac48Address::ConvertFrom (dst);
-	if (!m_promiscRxCallback.IsNull ())
-		m_promiscRxCallback (this, packet, protocol, src, dst, packetType);
-	switch (packetType)
-	{
-		case PACKET_HOST:
-			if (dst48 == m_address)
-				m_rxCallback (this, packet, protocol, src);
-			break;
-		case PACKET_BROADCAST:
-		case PACKET_MULTICAST:
-			m_rxCallback (this, packet, protocol, src);
-		case PACKET_OTHERHOST:
-			Forward (incomingPort, packet->Copy(), protocol, src48, dst48);
-			break;
-	}
+  NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_DEBUG ("UID is " << packet->GetUid ());
+  const Mac48Address src48 = Mac48Address::ConvertFrom (src);
+  const Mac48Address dst48 = Mac48Address::ConvertFrom (dst);
+  if (!m_promiscRxCallback.IsNull ())
+    m_promiscRxCallback (this, packet, protocol, src, dst, packetType);
+  switch (packetType)
+    {
+    case PACKET_HOST:
+      if (dst48 == m_address)
+        m_rxCallback (this, packet, protocol, src);
+      break;
+    case PACKET_BROADCAST:
+    case PACKET_MULTICAST:
+      m_rxCallback (this, packet, protocol, src);
+    case PACKET_OTHERHOST:
+      Forward (incomingPort, packet->Copy(), protocol, src48, dst48);
+      break;
+    }
 
 }
 
 void
 L2RoutingNetDevice::Forward (Ptr<NetDevice> inport, Ptr<Packet> packet,
-		uint16_t protocol, const Mac48Address src, const Mac48Address dst)
+                             uint16_t protocol, const Mac48Address src, const Mac48Address dst)
 {
-	//pass through routing protocol
-	m_requestRoute(inport->GetIfIndex(), src, dst, packet, protocol, m_myResponse);
+  //pass through routing protocol
+  m_requestRoute(inport->GetIfIndex(), src, dst, packet, protocol, m_myResponse);
 }
 
 uint32_t
 L2RoutingNetDevice::GetNPorts () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return m_ports.size ();
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return m_ports.size ();
+  }
 
 Ptr<NetDevice>
 L2RoutingNetDevice::GetPort (uint32_t n) const
-{
-	NS_ASSERT(m_ports.size () > n);
-	return m_ports[n];
-}
+  {
+    NS_ASSERT(m_ports.size () > n);
+    return m_ports[n];
+  }
 
 void
 L2RoutingNetDevice::AddPort (Ptr<NetDevice> routingPort)
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	NS_ASSERT (routingPort != this);
-	if (!Mac48Address::IsMatchingType (routingPort->GetAddress ()))
-		NS_FATAL_ERROR ("Device does not support eui 48 addresses: cannot be added to bridge.");
-	if (!routingPort->SupportsSendFrom ())
-		NS_FATAL_ERROR ("Device does not support SendFrom: cannot be added to bridge.");
-	m_address = Mac48Address::ConvertFrom (routingPort->GetAddress ());
-	NS_LOG_DEBUG ("RegisterProtocolHandler for " << routingPort->GetName ());
-	m_node->RegisterProtocolHandler (MakeCallback (&L2RoutingNetDevice::ReceiveFromDevice, this),
-			0, routingPort, true);
-	m_ports.push_back (routingPort);
-	m_channel->AddChannel (routingPort->GetChannel ());
+  NS_LOG_FUNCTION_NOARGS ();
+  NS_ASSERT (routingPort != this);
+  if (!Mac48Address::IsMatchingType (routingPort->GetAddress ()))
+    NS_FATAL_ERROR ("Device does not support eui 48 addresses: cannot be added to bridge.");
+  if (!routingPort->SupportsSendFrom ())
+    NS_FATAL_ERROR ("Device does not support SendFrom: cannot be added to bridge.");
+  m_address = Mac48Address::ConvertFrom (routingPort->GetAddress ());
+  NS_LOG_DEBUG ("RegisterProtocolHandler for " << routingPort->GetName ());
+  m_node->RegisterProtocolHandler (MakeCallback (&L2RoutingNetDevice::ReceiveFromDevice, this),
+                                   0, routingPort, true);
+  m_ports.push_back (routingPort);
+  m_channel->AddChannel (routingPort->GetChannel ());
 }
 
-	void
+void
 L2RoutingNetDevice::SetName(const std::string name)
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	m_name = name;
+  NS_LOG_FUNCTION_NOARGS ();
+  m_name = name;
 }
 
 std::string
 L2RoutingNetDevice::GetName() const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return m_name;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return m_name;
+  }
 
-	void
+void
 L2RoutingNetDevice::SetIfIndex(const uint32_t index)
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	m_ifIndex = index;
+  NS_LOG_FUNCTION_NOARGS ();
+  m_ifIndex = index;
 }
 
 uint32_t
 L2RoutingNetDevice::GetIfIndex() const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return m_ifIndex;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return m_ifIndex;
+  }
 
 Ptr<Channel>
 L2RoutingNetDevice::GetChannel () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return m_channel;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return m_channel;
+  }
 
 Address
 L2RoutingNetDevice::GetAddress () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return m_address;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return m_address;
+  }
 
-	bool
+bool
 L2RoutingNetDevice::SetMtu (const uint16_t mtu)
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	m_mtu = mtu;
-	return true;
+  NS_LOG_FUNCTION_NOARGS ();
+  m_mtu = mtu;
+  return true;
 }
 
 uint16_t
 L2RoutingNetDevice::GetMtu () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return 1500;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return 1500;
+  }
 
 
 bool
 L2RoutingNetDevice::IsLinkUp () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return true;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return true;
+  }
 
 
-	void
+void
 L2RoutingNetDevice::SetLinkChangeCallback (Callback<void> callback)
 {}
 
 bool
 L2RoutingNetDevice::IsBroadcast () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return true;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return true;
+  }
 
 
 Address
 L2RoutingNetDevice::GetBroadcast () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return Mac48Address ("ff:ff:ff:ff:ff:ff");
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return Mac48Address ("ff:ff:ff:ff:ff:ff");
+  }
 
 bool
 L2RoutingNetDevice::IsMulticast () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return true;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return true;
+  }
 
 Address
 L2RoutingNetDevice::GetMulticast (Ipv4Address multicastGroup) const
-{
-	NS_LOG_FUNCTION (this << multicastGroup);
-	Mac48Address multicast = Mac48Address::GetMulticast (multicastGroup);
-	return multicast;
-}
+  {
+    NS_LOG_FUNCTION (this << multicastGroup);
+    Mac48Address multicast = Mac48Address::GetMulticast (multicastGroup);
+    return multicast;
+  }
 
 
 bool
 L2RoutingNetDevice::IsPointToPoint () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return false;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return false;
+  }
 
 bool
 L2RoutingNetDevice::IsBridge () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return false;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return false;
+  }
 
 
 bool
 L2RoutingNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)
 {
 
-	const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);
-	return m_requestRoute(m_ifIndex, m_address, dst48, packet, protocolNumber, m_myResponse);
+  const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);
+  return m_requestRoute(m_ifIndex, m_address, dst48, packet, protocolNumber, m_myResponse);
 }
 
 bool
 L2RoutingNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)
 {
-	const Mac48Address src48 = Mac48Address::ConvertFrom (src);
-	const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);
-	return m_requestRoute(m_ifIndex, src48, dst48, packet, protocolNumber, m_myResponse);
+  const Mac48Address src48 = Mac48Address::ConvertFrom (src);
+  const Mac48Address dst48 = Mac48Address::ConvertFrom (dest);
+  return m_requestRoute(m_ifIndex, src48, dst48, packet, protocolNumber, m_myResponse);
 }
 
 
 Ptr<Node>
 L2RoutingNetDevice::GetNode () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return m_node;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return m_node;
+  }
 
 
-	void
+void
 L2RoutingNetDevice::SetNode (Ptr<Node> node)
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	m_node = node;
+  NS_LOG_FUNCTION_NOARGS ();
+  m_node = node;
 }
 
 
 bool
 L2RoutingNetDevice::NeedsArp () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return true;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return true;
+  }
 
 
-	void
+void
 L2RoutingNetDevice::SetReceiveCallback (NetDevice::ReceiveCallback cb)
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	m_rxCallback = cb;
+  NS_LOG_FUNCTION_NOARGS ();
+  m_rxCallback = cb;
 }
 
-	void
+void
 L2RoutingNetDevice::SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb)
 {
-	NS_LOG_FUNCTION_NOARGS ();
-	m_promiscRxCallback = cb;
+  NS_LOG_FUNCTION_NOARGS ();
+  m_promiscRxCallback = cb;
 }
 
 bool
 L2RoutingNetDevice::SupportsSendFrom () const
-{
-	NS_LOG_FUNCTION_NOARGS ();
-	return true;
-}
+  {
+    NS_LOG_FUNCTION_NOARGS ();
+    return true;
+  }
 
 Address
 L2RoutingNetDevice::GetMulticast (Ipv6Address addr) const
-{
-	NS_LOG_FUNCTION (this << addr);
-	return Mac48Address::GetMulticast (addr);
-}
+  {
+    NS_LOG_FUNCTION (this << addr);
+    return Mac48Address::GetMulticast (addr);
+  }
 //L2RouitingSpecific methods:
 
 bool
 L2RoutingNetDevice::AttachProtocol(Ptr<L2RoutingProtocol> protocol)
 {
-	m_requestRoute = MakeCallback(&L2RoutingProtocol::RequestRoute, protocol);
-	m_myResponse = MakeCallback(&L2RoutingNetDevice::ProtocolResponse, this);
-	protocol->SetIfIndex(m_ifIndex);
-	return protocol->AttachPorts(m_ports);
+  m_requestRoute = MakeCallback(&L2RoutingProtocol::RequestRoute, protocol);
+  m_myResponse = MakeCallback(&L2RoutingNetDevice::ProtocolResponse, this);
+  protocol->SetIfIndex(m_ifIndex);
+  return protocol->AttachPorts(m_ports);
 }
 
 void
 L2RoutingNetDevice::ProtocolResponse(
-		bool success,
-		Ptr<Packet> packet,
-		Mac48Address src,
-		Mac48Address dst,
-		uint16_t protocol,
-		uint32_t outPort
-		)
+  bool success,
+  Ptr<Packet> packet,
+  Mac48Address src,
+  Mac48Address dst,
+  uint16_t protocol,
+  uint32_t outPort
+)
 {
-	if(!success)
-	{
-		NS_LOG_UNCOND("Resolve failed");
-		//TODO: SendError callback
-		return;
-	}
-	//just do sendFrom!
-	if(outPort!=0xffffffff)
-		GetPort(outPort)->SendFrom(packet, src, dst, protocol);
-	else
-		for(std::vector<Ptr<NetDevice> >::iterator i = m_ports.begin(); i!= m_ports.end(); i++)
-			(*i) -> SendFrom(packet, src, dst, protocol);
+  if (!success)
+    {
+      NS_LOG_UNCOND("Resolve failed");
+      //TODO: SendError callback
+      return;
+    }
+  //just do sendFrom!
+  if (outPort!=0xffffffff)
+    GetPort(outPort)->SendFrom(packet, src, dst, protocol);
+  else
+    for (std::vector<Ptr<NetDevice> >::iterator i = m_ports.begin(); i != m_ports.end(); i++)
+      (*i) -> SendFrom(packet, src, dst, protocol);
 }
 
 } // namespace ns3
diff --git a/src/devices/l2-routing/l2-routing-main/l2-routing-net-device.h b/src/devices/l2-routing/l2-routing-main/l2-routing-net-device.h
index 08e394979..768ab3dcc 100644
--- a/src/devices/l2-routing/l2-routing-main/l2-routing-net-device.h
+++ b/src/devices/l2-routing/l2-routing-main/l2-routing-net-device.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -30,137 +30,130 @@
 #include "ns3/l2-routing-protocol.h"
 
 namespace ns3 {
-	class Node;
-	/**
-	 * \ingroup mesh
-	 * 
-	 * \brief a virtual net device that may forward packets
-	 * between real network devices using routing protocols of
-	 * MAC-layer
-	 * 
-	 * \details This is a virtual netdevice, which aggreagates
-	 * real netdevices and uses interface of L2RoutingProtocol to
-	 * forward packets
-	 * 
-	 * \attention The idea of L2RoutingNetDevice is similar to
-	 * BridgeNetDevice, but the packets, which going through
-	 * L2RoutingNetDevice may be changed (because routing protocol
-	 * may require its own headers or tags). 
-	 */
-	class L2RoutingNetDevice : public NetDevice
-	{
-		public:
-			static TypeId GetTypeId ();
-			L2RoutingNetDevice ();
-			virtual ~L2RoutingNetDevice ();
-			/**
-			 * \brief Attaches a 'port' to a virtual
-			 * L2RoutingNetDevice, and this port is handled
-			 * by L2RoutingProtocol.
-			 * \attention Like in a bridge,
-			 * L2RoutingNetDevice's ports must not have IP
-			 * addresses, and only L2RoutingNetDevice
-			 * itself may have an IP address.
-			 *
-			 * \attention L2RoutingNetDevice may be a port
-			 * of BridgeNetDevice.
-			 */
-			void AddPort (Ptr<NetDevice> port);
-			/**
-			 * \returns number of ports attached to
-			 * L2RoutingNetDevice
-			 */
-			uint32_t GetNPorts () const;
-			/**
-			 * \returns a pointer to netdevice
-			 * \param n is device ID to be returned
-			 */
-			Ptr<NetDevice> GetPort (uint32_t n) const;
-			//inherited from netdevice:
-			virtual void SetName(const std::string name);
-			virtual std::string GetName() const;
-			virtual void SetIfIndex(const uint32_t index);
-			virtual uint32_t GetIfIndex() const;
-			virtual Ptr<Channel> GetChannel () const;
-			virtual Address GetAddress () const;
-			virtual bool SetMtu (const uint16_t mtu);
-			virtual uint16_t GetMtu () const;
-			virtual bool IsLinkUp () const;
-			virtual void SetLinkChangeCallback (Callback<void> callback);
-			virtual bool IsBroadcast () const;
-			virtual Address GetBroadcast () const;
-			virtual bool IsMulticast () const;
-			virtual Address GetMulticast (Ipv4Address multicastGroup) const;
-			virtual bool IsPointToPoint () const;
-			virtual bool IsBridge () const;
-			virtual bool Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);
-			virtual bool SendFrom (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);
-			virtual Ptr<Node> GetNode () const;
-			virtual void SetNode (Ptr<Node> node);
-			virtual bool NeedsArp () const;
-			virtual void SetReceiveCallback (NetDevice::ReceiveCallback cb);
-			virtual void SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb);
-			virtual bool SupportsSendFrom () const;
-			virtual Address GetMulticast (Ipv6Address addr) const;
-			virtual void DoDispose ();
-			/**
-			 * \brief Attaches protocol to a given virtual
-			 * device
-			 * \returns true if success
-			 */
-			virtual bool AttachProtocol(Ptr<L2RoutingProtocol> protocol);
-		protected:
-			/**
-			 * \brief This is similar to BridgeNetDevice
-			 * method
-			 */
-			void ReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol,
-					Address const &source, Address const &destination, PacketType packetType);
-			/**
-			 * \brief This is similar to BridgeNetDevice
-			 * method
-			 */
-			void Forward (Ptr<NetDevice> incomingPort, Ptr<Packet> packet,
-					uint16_t protocol, const Mac48Address src, const Mac48Address dst);
-			/**
-			 * \brief This is a function, which should be
-			 * passed to L2RoutingProtocol as response
-			 * callback (see L2RoutingProtocol).
-			 */
-			virtual void ProtocolResponse(
-					bool success,
-					Ptr<Packet>,
-					Mac48Address src,
-					Mac48Address dst,
-					uint16_t protocol,
-					uint32_t outPort
-					);
-		private:
-			NetDevice::ReceiveCallback
-					m_rxCallback;
-			NetDevice::PromiscReceiveCallback
-					m_promiscRxCallback;
-			Mac48Address	m_address;
-			Ptr<Node>	m_node;
-			std::string	m_name;
-			std::vector< Ptr<NetDevice> >
-					m_ports;
-			uint32_t	m_ifIndex;
-			uint16_t	m_mtu;
-			Ptr<BridgeChannel>
-					m_channel;
-			Callback<
-				bool,
-				uint32_t,
-				Mac48Address,
-				Mac48Address,
-				Ptr<Packet>,
-				uint16_t,
-				L2RoutingProtocol::RouteReplyCallback>
-					m_requestRoute;
-			//What we give to L2Routing
-			L2RoutingProtocol::RouteReplyCallback
-					m_myResponse;
-	};
+class Node;
+/**
+ * \ingroup mesh
+ *
+ * \brief a virtual net device that may forward packets
+ * between real network devices using routing protocols of
+ * MAC-layer
+ *
+ * \details This is a virtual netdevice, which aggreagates
+ * real netdevices and uses interface of L2RoutingProtocol to
+ * forward packets
+ *
+ * \attention The idea of L2RoutingNetDevice is similar to
+ * BridgeNetDevice, but the packets, which going through
+ * L2RoutingNetDevice may be changed (because routing protocol
+ * may require its own headers or tags).
+ */
+class L2RoutingNetDevice : public NetDevice
+{
+public:
+  static TypeId GetTypeId ();
+  L2RoutingNetDevice ();
+  virtual ~L2RoutingNetDevice ();
+  /**
+   * \brief Attaches a 'port' to a virtual
+   * L2RoutingNetDevice, and this port is handled
+   * by L2RoutingProtocol.
+   * \attention Like in a bridge,
+   * L2RoutingNetDevice's ports must not have IP
+   * addresses, and only L2RoutingNetDevice
+   * itself may have an IP address.
+   *
+   * \attention L2RoutingNetDevice may be a port
+   * of BridgeNetDevice.
+   */
+  void AddPort (Ptr<NetDevice> port);
+  /**
+   * \returns number of ports attached to
+   * L2RoutingNetDevice
+   */
+  uint32_t GetNPorts () const;
+  /**
+   * \returns a pointer to netdevice
+   * \param n is device ID to be returned
+   */
+  Ptr<NetDevice> GetPort (uint32_t n) const;
+  //inherited from netdevice:
+  virtual void SetName(const std::string name);
+  virtual std::string GetName() const;
+  virtual void SetIfIndex(const uint32_t index);
+  virtual uint32_t GetIfIndex() const;
+  virtual Ptr<Channel> GetChannel () const;
+  virtual Address GetAddress () const;
+  virtual bool SetMtu (const uint16_t mtu);
+  virtual uint16_t GetMtu () const;
+  virtual bool IsLinkUp () const;
+  virtual void SetLinkChangeCallback (Callback<void> callback);
+  virtual bool IsBroadcast () const;
+  virtual Address GetBroadcast () const;
+  virtual bool IsMulticast () const;
+  virtual Address GetMulticast (Ipv4Address multicastGroup) const;
+  virtual bool IsPointToPoint () const;
+  virtual bool IsBridge () const;
+  virtual bool Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber);
+  virtual bool SendFrom (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);
+  virtual Ptr<Node> GetNode () const;
+  virtual void SetNode (Ptr<Node> node);
+  virtual bool NeedsArp () const;
+  virtual void SetReceiveCallback (NetDevice::ReceiveCallback cb);
+  virtual void SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb);
+  virtual bool SupportsSendFrom () const;
+  virtual Address GetMulticast (Ipv6Address addr) const;
+  virtual void DoDispose ();
+  /**
+   * \brief Attaches protocol to a given virtual
+   * device
+   * \returns true if success
+   */
+  virtual bool AttachProtocol(Ptr<L2RoutingProtocol> protocol);
+protected:
+  /**
+   * \brief This is similar to BridgeNetDevice
+   * method
+   */
+  void ReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol,
+                          Address const &source, Address const &destination, PacketType packetType);
+  /**
+   * \brief This is similar to BridgeNetDevice
+   * method
+   */
+  void Forward (Ptr<NetDevice> incomingPort, Ptr<Packet> packet,
+                uint16_t protocol, const Mac48Address src, const Mac48Address dst);
+  /**
+   * \brief This is a function, which should be
+   * passed to L2RoutingProtocol as response
+   * callback (see L2RoutingProtocol).
+   */
+  virtual void ProtocolResponse(
+    bool success,
+    Ptr<Packet>,
+    Mac48Address src,
+    Mac48Address dst,
+    uint16_t protocol,
+    uint32_t outPort
+  );
+private:
+  NetDevice::ReceiveCallback   m_rxCallback;
+  NetDevice::PromiscReceiveCallback  m_promiscRxCallback;
+  Mac48Address m_address;
+  Ptr<Node> m_node;
+  std::string m_name;
+  std::vector< Ptr<NetDevice> >  m_ports;
+  uint32_t m_ifIndex;
+  uint16_t m_mtu;
+  Ptr<BridgeChannel>  m_channel;
+  Callback<bool,
+           uint32_t,
+           Mac48Address,
+           Mac48Address,
+           Ptr<Packet>,
+           uint16_t,
+           L2RoutingProtocol::RouteReplyCallback>  m_requestRoute;
+  //What we give to L2Routing
+  L2RoutingProtocol::RouteReplyCallback  m_myResponse;
+};
 } //namespace ns3
 #endif
diff --git a/src/devices/mesh/mesh.h b/src/devices/mesh/mesh.h
index ab11c8694..e71916856 100644
--- a/src/devices/mesh/mesh.h
+++ b/src/devices/mesh/mesh.h
@@ -1,7 +1,7 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/* 
+/*
  * Copyright (c) 2009 IITP RAS
- * 
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
@@ -14,17 +14,17 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- * 
+ *
  * Author: Pavel Boyko <boyko@iitp.ru>
- * 
+ *
  * This is toplevel mesh module description
  */
 
 /**
  * \ingroup devices
  * \defgroup mesh Mesh
- * 
+ *
  * \brief Level 2 mobile ad hoc wireless networking
- * 
+ *
  * TODO module documentation here
  */
\ No newline at end of file
diff --git a/src/devices/wifi/dot11s-codes.h b/src/devices/wifi/dot11s-codes.h
index c06ce3d88..cfd011b80 100644
--- a/src/devices/wifi/dot11s-codes.h
+++ b/src/devices/wifi/dot11s-codes.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -29,69 +29,69 @@ namespace ns3 {
  * \ingroup mesh
  */
 enum dot11sElementID {
-	IE11S_MESH_CONFIGURATION = 18,
-	IE11S_MESH_ID,
-	IE11S_LINK_METRIC_REPORT,
-	IE11S_CONGESTION_NOTIFICATION,
-	IE11S_PEER_LINK_MANAGEMENT,
-	IE11S_MESH_CHANNEL_SWITCH_ANNOUNCEMENT,
-	IE11S_MESH_TIM,
-	IE11S_AWAKE_WINDOW,
-	IE11S_SYNCHRONIZATION_PROTOCOL,
-	IE11S_BEACON_TIMING,
-	IE11S_MDAOP_SETUP_REQUEST,
-	IE11S_MDAOP_SETUP_REPLY,
-	IE11S_MDAOP_ADVERTISEMENT,
-	IE11S_MDAOP_SET_TEARDOWN,
-	IE11S_CONNECTIVITY_REPORT,
-	IE11S_PORTAL_ANNOUNCEMENT,
-	IE11S_RANN,
-	IE11S_PREQ,
-	IE11S_PREP,
-	IE11S_PERR,
-	IE11S_PROXY_UPDATE,
-	IE11S_PROXY_UPDATE_CONFIRMATION,
-	IE11S_MSCIE,
-	IE11S_MSAIE,
+  IE11S_MESH_CONFIGURATION = 18,
+  IE11S_MESH_ID,
+  IE11S_LINK_METRIC_REPORT,
+  IE11S_CONGESTION_NOTIFICATION,
+  IE11S_PEER_LINK_MANAGEMENT,
+  IE11S_MESH_CHANNEL_SWITCH_ANNOUNCEMENT,
+  IE11S_MESH_TIM,
+  IE11S_AWAKE_WINDOW,
+  IE11S_SYNCHRONIZATION_PROTOCOL,
+  IE11S_BEACON_TIMING,
+  IE11S_MDAOP_SETUP_REQUEST,
+  IE11S_MDAOP_SETUP_REPLY,
+  IE11S_MDAOP_ADVERTISEMENT,
+  IE11S_MDAOP_SET_TEARDOWN,
+  IE11S_CONNECTIVITY_REPORT,
+  IE11S_PORTAL_ANNOUNCEMENT,
+  IE11S_RANN,
+  IE11S_PREQ,
+  IE11S_PREP,
+  IE11S_PERR,
+  IE11S_PROXY_UPDATE,
+  IE11S_PROXY_UPDATE_CONFIRMATION,
+  IE11S_MSCIE,
+  IE11S_MSAIE,
 };
 
 /**
  * \ingroup mesh
  */
 enum dot11sReasonCode {
-	REASON11S_PEER_LINK_CANCELLED,
-	REASON11S_MESH_MAX_PEERS,
-	REASON11S_MESH_CAPABILITY_POLICY_VIOLATION,
-	REASON11S_MESH_CLOSE_RCVD,
-	REASON11S_MESH_MAX_RETRIES,
-	REASON11S_MESH_CONFIRM_TIMEOUT,
-	REASON11S_MESH_SECURITY_ROLE_NEGOTIATION_DIFFERS,
-	REASON11S_MESH_SECURITY_AUTHENTICATION_IMPOSSIBLE,
-	REASON11S_MESH_SECURITY_FAILED_VERIFICATION,
-	REASON11S_MESH_INVALID_GTK,
-	REASON11S_MESH_MISMATCH_GTK,
-	REASON11S_MESH_INCONSISTENT_PARAMETERS,
-	REASON11S_MESH_CONFIGURATION_POLICY_VIOLATION,
-	REASON11S_RESERVED,
+  REASON11S_PEER_LINK_CANCELLED,
+  REASON11S_MESH_MAX_PEERS,
+  REASON11S_MESH_CAPABILITY_POLICY_VIOLATION,
+  REASON11S_MESH_CLOSE_RCVD,
+  REASON11S_MESH_MAX_RETRIES,
+  REASON11S_MESH_CONFIRM_TIMEOUT,
+  REASON11S_MESH_SECURITY_ROLE_NEGOTIATION_DIFFERS,
+  REASON11S_MESH_SECURITY_AUTHENTICATION_IMPOSSIBLE,
+  REASON11S_MESH_SECURITY_FAILED_VERIFICATION,
+  REASON11S_MESH_INVALID_GTK,
+  REASON11S_MESH_MISMATCH_GTK,
+  REASON11S_MESH_INCONSISTENT_PARAMETERS,
+  REASON11S_MESH_CONFIGURATION_POLICY_VIOLATION,
+  REASON11S_RESERVED,
 };
 
 /**
  * \ingroup mesh
  */
 enum dot11sStatusCode {
-	STATUS11S_PEAR_LINK_ESTABLISHED,
-	STATUS11S_PEAR_LINK_CLOSED,
-	STATUS11S_NO_LISTED_KEY_HOLDER,
-	STATUS11S_MESH_KEY_HANDSHAKE_MALFORMED,
-	STATUS11S_PEAR_LINK_MAX_RETRIES,
-	STATUS11S_PEAR_LINK_NO_PMK,
-	STATUS11S_PEAR_LINK_ALT_PMK,
-	STATUS11S_PEAR_LINK_NO_AKM,
-	STATUS11S_PEAR_LINK_ALT_AKM,
-	STATUS11S_PEAR_LINK_NO_KDF,
-	STATUS11S_PEAR_LINK_SA_ESTABLISHED,
-	STATUS11S_AUTHENTICATION_REJECTED_CLOGGING,
-	STATUS11S_RESERVED,
+  STATUS11S_PEAR_LINK_ESTABLISHED,
+  STATUS11S_PEAR_LINK_CLOSED,
+  STATUS11S_NO_LISTED_KEY_HOLDER,
+  STATUS11S_MESH_KEY_HANDSHAKE_MALFORMED,
+  STATUS11S_PEAR_LINK_MAX_RETRIES,
+  STATUS11S_PEAR_LINK_NO_PMK,
+  STATUS11S_PEAR_LINK_ALT_PMK,
+  STATUS11S_PEAR_LINK_NO_AKM,
+  STATUS11S_PEAR_LINK_ALT_AKM,
+  STATUS11S_PEAR_LINK_NO_KDF,
+  STATUS11S_PEAR_LINK_SA_ESTABLISHED,
+  STATUS11S_AUTHENTICATION_REJECTED_CLOGGING,
+  STATUS11S_RESERVED,
 };
 
 }
diff --git a/src/devices/wifi/dot11s-parameters.cc b/src/devices/wifi/dot11s-parameters.cc
index 18f23cc4e..34bc30955 100644
--- a/src/devices/wifi/dot11s-parameters.cc
+++ b/src/devices/wifi/dot11s-parameters.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -22,8 +22,7 @@
 
 #include "ns3/dot11s-parameters.h"
 
-namespace ns3
-{
+namespace ns3 {
 
 uint8_t dot11sParameters::dot11MeshMaxRetries      = 4;
 Time    dot11sParameters::dot11MeshRetryTimeout    = TU_TO_TIME(40);
diff --git a/src/devices/wifi/dot11s-parameters.h b/src/devices/wifi/dot11s-parameters.h
index a60b94d70..67b4dec74 100644
--- a/src/devices/wifi/dot11s-parameters.h
+++ b/src/devices/wifi/dot11s-parameters.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -22,34 +22,33 @@
 
 #ifndef DOT11S_PARAMETERS_H
 #define DOT11S_PARAMETERS_H
-#include "ns3/uinteger.h" 
+#include "ns3/uinteger.h"
 #include "ns3/nstime.h"
 
-namespace ns3
-{
+namespace ns3 {
 
-#define TU_TO_TIME(x)	MicroSeconds(x*1024)
-#define TIME_TO_TU(x)	x.GetMicroSeconds()/1024
+#define TU_TO_TIME(x) MicroSeconds(x*1024)
+#define TIME_TO_TU(x) x.GetMicroSeconds()/1024
 
 /**
   * \ingroup mesh
 */
 struct dot11sParameters
 {
-	/** Peer Link  */
-	static uint8_t	dot11MeshMaxRetries;
-	static Time	dot11MeshRetryTimeout;
-	static Time	dot11MeshHoldingTimeout;
-	static Time	dot11MeshConfirmTimeout;
-	/** HWMP */
-	static uint8_t	dot11MeshHWMPmaxPREQretries;
-	static Time	dot11MeshHWMPnetDiameterTraversalTime;
-	static Time	dot11MeshHWMPpreqMinInterval;
-	static Time	dot11MeshHWMPperrMinInterval;
-	static Time	dot11MeshHWMPactiveRootTimeout;
-	static Time	dot11MeshHWMPactivePathTimeout;
-	static Time	dot11MeshHWMPpathToRootInterval;
-	static Time	dot11MeshHWMPrannInterval;
+  /** Peer Link  */
+  static uint8_t dot11MeshMaxRetries;
+  static Time dot11MeshRetryTimeout;
+  static Time dot11MeshHoldingTimeout;
+  static Time dot11MeshConfirmTimeout;
+  /** HWMP */
+  static uint8_t dot11MeshHWMPmaxPREQretries;
+  static Time dot11MeshHWMPnetDiameterTraversalTime;
+  static Time dot11MeshHWMPpreqMinInterval;
+  static Time dot11MeshHWMPperrMinInterval;
+  static Time dot11MeshHWMPactiveRootTimeout;
+  static Time dot11MeshHWMPactivePathTimeout;
+  static Time dot11MeshHWMPpathToRootInterval;
+  static Time dot11MeshHWMPrannInterval;
 };
 
 };
diff --git a/src/devices/wifi/dot11s-peer-management-element.cc b/src/devices/wifi/dot11s-peer-management-element.cc
index a027d44d5..3323f777d 100644
--- a/src/devices/wifi/dot11s-peer-management-element.cc
+++ b/src/devices/wifi/dot11s-peer-management-element.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -29,26 +29,26 @@
 namespace ns3 {
 
 PeerLinkManagementElement::PeerLinkManagementElement ():
-	m_length(0),
-  m_subtype(PEER_OPEN),
-	m_localLinkId(0),
-	m_peerLinkId(0),
-	m_reasonCode(REASON11S_RESERVED)
+    m_length(0),
+    m_subtype(PEER_OPEN),
+    m_localLinkId(0),
+    m_peerLinkId(0),
+    m_reasonCode(REASON11S_RESERVED)
 {}
 
 
-void 
+void
 PeerLinkManagementElement::SetPeerOpen(uint16_t localLinkId)
 {
-  m_length = 3; 
-  m_subtype=PEER_OPEN;
+  m_length = 3;
+  m_subtype = PEER_OPEN;
   m_localLinkId = localLinkId;
 }
-void 
+void
 PeerLinkManagementElement::SetPeerClose(uint16_t localLinkId, uint16_t peerLinkId, dot11sReasonCode reasonCode)
 {
-  m_length = 7; 
-  m_subtype=PEER_CLOSE;
+  m_length = 7;
+  m_subtype = PEER_CLOSE;
   m_localLinkId = localLinkId;
   m_peerLinkId = peerLinkId;
   m_reasonCode = reasonCode;
@@ -57,76 +57,76 @@ PeerLinkManagementElement::SetPeerClose(uint16_t localLinkId, uint16_t peerLinkI
 void
 PeerLinkManagementElement::SetPeerConfirm(uint16_t localLinkId, uint16_t peerLinkId)
 {
-  m_length = 5; 
-  m_subtype=PEER_CONFIRM;
+  m_length = 5;
+  m_subtype = PEER_CONFIRM;
   m_localLinkId = localLinkId;
   m_peerLinkId = peerLinkId;
 }
 
 dot11sReasonCode
 PeerLinkManagementElement::GetReasonCode() const
-{
-	return m_reasonCode;
-}
+  {
+    return m_reasonCode;
+  }
 
 uint16_t
 PeerLinkManagementElement::GetLocalLinkId() const
-{
-	return m_localLinkId;
-}
+  {
+    return m_localLinkId;
+  }
 
 uint16_t
 PeerLinkManagementElement::GetPeerLinkId() const
-{
-	return m_peerLinkId;
-}
+  {
+    return m_peerLinkId;
+  }
 
 uint32_t
 PeerLinkManagementElement::GetSerializedSize (void) const
-{
-	return m_length+2;
-}
+  {
+    return m_length+2;
+  }
 
 bool
 PeerLinkManagementElement::SubtypeIsOpen() const
-{
-	return (m_subtype == PEER_OPEN);
-}
+  {
+    return (m_subtype == PEER_OPEN);
+  }
 bool
 PeerLinkManagementElement::SubtypeIsClose() const
-{
-	return (m_subtype == PEER_CLOSE);
-}
+  {
+    return (m_subtype == PEER_CLOSE);
+  }
 bool
 PeerLinkManagementElement::SubtypeIsConfirm() const
-{
-	return (m_subtype == PEER_CONFIRM);
-}
+  {
+    return (m_subtype == PEER_CONFIRM);
+  }
 
 Buffer::Iterator
 PeerLinkManagementElement::Serialize (Buffer::Iterator i) const
-{
-	i.WriteU8(ElementId());
-	i.WriteU8(m_length);
-	i.WriteU8(m_subtype);
-	i.WriteHtonU16(m_localLinkId);
-	if(m_length > 3)
-		i.WriteHtonU16(m_peerLinkId);
-	if(m_length > 5)
-		i.WriteHtonU16(m_reasonCode);
-	return i;
-}
+  {
+    i.WriteU8(ElementId());
+    i.WriteU8(m_length);
+    i.WriteU8(m_subtype);
+    i.WriteHtonU16(m_localLinkId);
+    if (m_length > 3)
+      i.WriteHtonU16(m_peerLinkId);
+    if (m_length > 5)
+      i.WriteHtonU16(m_reasonCode);
+    return i;
+  }
 Buffer::Iterator
 PeerLinkManagementElement::Deserialize (Buffer::Iterator i)
 {
-	NS_ASSERT(ElementId() == i.ReadU8());
-	m_length		= i.ReadU8();
-	m_subtype		= i.ReadU8();
-	m_localLinkId 	= i.ReadNtohU16();
-	if(m_length > 3)
-		m_peerLinkId	= i.ReadNtohU16();
-	if(m_length > 5)
-		m_reasonCode	= (dot11sReasonCode)i.ReadNtohU16();
-	return i;
+  NS_ASSERT(ElementId() == i.ReadU8());
+  m_length   = i.ReadU8();
+  m_subtype  = i.ReadU8();
+  m_localLinkId  = i.ReadNtohU16();
+  if (m_length > 3)
+    m_peerLinkId = i.ReadNtohU16();
+  if (m_length > 5)
+    m_reasonCode = (dot11sReasonCode)i.ReadNtohU16();
+  return i;
 }
 } //namespace NS3
diff --git a/src/devices/wifi/dot11s-peer-management-element.h b/src/devices/wifi/dot11s-peer-management-element.h
index ff068ab1b..1165226d1 100644
--- a/src/devices/wifi/dot11s-peer-management-element.h
+++ b/src/devices/wifi/dot11s-peer-management-element.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -23,47 +23,48 @@
 #ifndef MESH_PEER_MAN_ELEMENT
 #define MESH_PEER_MAN_ELEMENT
 
-#include	<stdint.h>
-#include	"ns3/buffer.h"
-#include	"dot11s-codes.h"
+#include <stdint.h>
+#include "ns3/buffer.h"
+#include "dot11s-codes.h"
 
-namespace ns3
-{
+namespace ns3 {
 /**
  * \ingroup mesh
  */
 class PeerLinkManagementElement
 {
-	public:
-		enum Subtype {
-			PEER_OPEN    = 0,
-			PEER_CLOSE   = 1,
-			PEER_CONFIRM = 2,
-		};
-	public:
-		PeerLinkManagementElement ();
-		
-		void			SetPeerOpen(uint16_t localLinkId);
-		void			SetPeerClose(uint16_t localLinkID, uint16_t peerLinkId, dot11sReasonCode reasonCode);
-		void			SetPeerConfirm(uint16_t localLinkID, uint16_t peerLinkId);
-	
-		dot11sReasonCode	GetReasonCode() const;
-		uint16_t		GetLocalLinkId() const;
-		uint16_t		GetPeerLinkId() const;
-		bool			SubtypeIsOpen() const;
-		bool			SubtypeIsClose() const;
-		bool			SubtypeIsConfirm() const ;
+public:
+  enum Subtype {
+    PEER_OPEN    = 0,
+    PEER_CLOSE   = 1,
+    PEER_CONFIRM = 2,
+  };
+public:
+  PeerLinkManagementElement ();
 
-		uint32_t		GetSerializedSize (void) const;
-		Buffer::Iterator	Serialize (Buffer::Iterator i) const;
-		Buffer::Iterator	Deserialize (Buffer::Iterator i);
-	private:
-		static uint8_t ElementId() { return (uint8_t)IE11S_PEER_LINK_MANAGEMENT; }
-		uint8_t			m_length;
-		uint8_t			m_subtype;
-		uint16_t		m_localLinkId;	//always is present
-		uint16_t		m_peerLinkId;	//only in confirm and may be present in close frame
-		dot11sReasonCode	m_reasonCode;	//only in close frame
+  void   SetPeerOpen(uint16_t localLinkId);
+  void   SetPeerClose(uint16_t localLinkID, uint16_t peerLinkId, dot11sReasonCode reasonCode);
+  void   SetPeerConfirm(uint16_t localLinkID, uint16_t peerLinkId);
+
+  dot11sReasonCode GetReasonCode() const;
+  uint16_t  GetLocalLinkId() const;
+  uint16_t  GetPeerLinkId() const;
+  bool   SubtypeIsOpen() const;
+  bool   SubtypeIsClose() const;
+  bool   SubtypeIsConfirm() const ;
+
+  uint32_t  GetSerializedSize (void) const;
+  Buffer::Iterator Serialize (Buffer::Iterator i) const;
+  Buffer::Iterator Deserialize (Buffer::Iterator i);
+private:
+  static uint8_t ElementId() {
+    return (uint8_t)IE11S_PEER_LINK_MANAGEMENT;
+  }
+  uint8_t   m_length;
+  uint8_t   m_subtype;
+  uint16_t  m_localLinkId; //always is present
+  uint16_t  m_peerLinkId; //only in confirm and may be present in close frame
+  dot11sReasonCode m_reasonCode; //only in close frame
 };
 } //namespace NS3
 #endif
diff --git a/src/devices/wifi/mesh-configuration-element.cc b/src/devices/wifi/mesh-configuration-element.cc
index b45bb9674..06c225671 100644
--- a/src/devices/wifi/mesh-configuration-element.cc
+++ b/src/devices/wifi/mesh-configuration-element.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -28,119 +28,118 @@
 namespace ns3 {
 
 dot11sMeshCapability::dot11sMeshCapability():
-  acceptPeerLinks(true),
-  MDAEnabled(false),
-  forwarding(true),
-  beaconTimingReport(false),
-  TBTTAdjustment(false),
-  powerSaveLevel(false)
+    acceptPeerLinks(true),
+    MDAEnabled(false),
+    forwarding(true),
+    beaconTimingReport(false),
+    TBTTAdjustment(false),
+    powerSaveLevel(false)
 {}
 
-uint32_t	dot11sMeshCapability::GetSerializedSize () const
-{
-  return 2;
-}
-	
-Buffer::Iterator	dot11sMeshCapability::Serialize (Buffer::Iterator i) const
-{
-  uint16_t result = 0;
-  if(acceptPeerLinks)
-    result |= 1 << 0;
-  if(MDAEnabled)
-    result |= 1 << 1;
-  if(forwarding)
-    result |= 1 << 2;
-  if(beaconTimingReport)
-    result |= 1 << 3;
-  if(TBTTAdjustment)
-    result |= 1 << 4;
-  if(powerSaveLevel)
-    result |= 1 << 5;
-	i.WriteHtonU16(result);
-  return i;
-}
+uint32_t dot11sMeshCapability::GetSerializedSize () const
+  {
+    return 2;
+  }
 
-Buffer::Iterator	dot11sMeshCapability::Deserialize (Buffer::Iterator i)
+Buffer::Iterator dot11sMeshCapability::Serialize (Buffer::Iterator i) const
+  {
+    uint16_t result = 0;
+    if (acceptPeerLinks)
+      result |= 1 << 0;
+    if (MDAEnabled)
+      result |= 1 << 1;
+    if (forwarding)
+      result |= 1 << 2;
+    if (beaconTimingReport)
+      result |= 1 << 3;
+    if (TBTTAdjustment)
+      result |= 1 << 4;
+    if (powerSaveLevel)
+      result |= 1 << 5;
+    i.WriteHtonU16(result);
+    return i;
+  }
+
+Buffer::Iterator dot11sMeshCapability::Deserialize (Buffer::Iterator i)
 {
   uint16_t  cap = i.ReadNtohU16();
-  acceptPeerLinks = Is(cap,0);
-  MDAEnabled = Is(cap,1);
-  forwarding = Is(cap,2);
-  beaconTimingReport = Is(cap,3);
-  TBTTAdjustment = Is(cap,4);
-  powerSaveLevel = Is(cap,5);
+  acceptPeerLinks = Is(cap, 0);
+  MDAEnabled = Is(cap, 1);
+  forwarding = Is(cap, 2);
+  beaconTimingReport = Is(cap, 3);
+  TBTTAdjustment = Is(cap, 4);
+  powerSaveLevel = Is(cap, 5);
   return i;
 }
 
-bool dot11sMeshCapability::Is(uint16_t cap, uint8_t n) const 
-{
-  uint16_t mask = 1<<n;
-  return (cap & mask) == mask;
-}
+bool dot11sMeshCapability::Is(uint16_t cap, uint8_t n) const
+  {
+    uint16_t mask = 1<<n;
+    return (cap & mask) == mask;
+  }
 
 MeshConfigurationElement::MeshConfigurationElement ():
-  m_APSId(PROTOCOL_HWMP),
-  m_APSMId(METRIC_AIRTIME),
-  m_CCMId(CONGESTION_DEFAULT),
-  m_CP(CHANNEL_PRECEDENCE_OFF)
+    m_APSId(PROTOCOL_HWMP),
+    m_APSMId(METRIC_AIRTIME),
+    m_CCMId(CONGESTION_DEFAULT),
+    m_CP(CHANNEL_PRECEDENCE_OFF)
 {}
 
 uint32_t
 MeshConfigurationElement::GetSerializedSize () const
-{
-	return  1 // ID
-		+ 1 // Length
-		+ 1 // Version
-		+ 4 // APSPId
-		+ 4 // APSMId
-		+ 4 // CCMId
-		+ 4 // CP
-		+ m_meshCap.GetSerializedSize()
-		;
-}
+  {
+    return    1 // ID
+            + 1 // Length
+            + 1 // Version
+            + 4 // APSPId
+            + 4 // APSMId
+            + 4 // CCMId
+            + 4 // CP
+            + m_meshCap.GetSerializedSize();
+  }
 
 Buffer::Iterator
 MeshConfigurationElement::Serialize (Buffer::Iterator i) const
-{
+  {
 
-	i.WriteU8 (ElementId());
-	i.WriteU8 (GetSerializedSize());	// Length
-	i.WriteU8 (1);	//Version
-	// Active Path Selection Protocol ID:
-	i.WriteHtonU32(m_APSId);
-	// Active Path Metric ID:
-	i.WriteHtonU32(m_APSMId);
-	// Congestion Control Mode ID:
-	i.WriteU32(m_CCMId);
-	// Channel Precedence:
-	i.WriteU32(m_CP);
-	i = m_meshCap.Serialize(i);
-	return i;
-}
+    i.WriteU8 (ElementId());
+    i.WriteU8 (GetSerializedSize()); // Length
+    i.WriteU8 (1); //Version
+    // Active Path Selection Protocol ID:
+    i.WriteHtonU32 (m_APSId);
+    // Active Path Metric ID:
+    i.WriteHtonU32 (m_APSMId);
+    // Congestion Control Mode ID:
+    i.WriteU32 (m_CCMId);
+    // Channel Precedence:
+    i.WriteU32 (m_CP);
+    i = m_meshCap.Serialize (i);
+    return i;
+  }
 
 Buffer::Iterator
 MeshConfigurationElement::Deserialize (Buffer::Iterator i)
 {
 
-	//uint8_t	elementId;
-	uint8_t 	size;
-	uint8_t	version;
-	//elementId	= i.ReadU8 ();
-	
-	NS_ASSERT (ElementId() == i.ReadU8());
-	
-	size		= i.ReadU8 ();
-	version		= i.ReadU8();
-	// Active Path Selection Protocol ID:
-	m_APSId		= (dot11sPathSelectionProtocol)i.ReadNtohU32();
-	// Active Path Metric ID:
-	m_APSMId	= (dot11sPathSelectionMetric)i.ReadNtohU32();
-	// Congestion Control Mode ID:
-	m_CCMId		= (dot11sCongestionControlMode)i.ReadU32();
-	// Channel Precedence:
-	m_CP		= (dot11sChannelPrecedence)i.ReadU32();
-	i = m_meshCap.Deserialize(i);
-	return i;
+  //uint8_t elementId;
+  uint8_t size;
+  uint8_t version;
+  //elementId = i.ReadU8 ();
+
+  NS_ASSERT (ElementId() == i.ReadU8());
+
+  size     = i.ReadU8 ();
+  version  = i.ReadU8 ();
+  // Active Path Selection Protocol ID:
+  m_APSId  = (dot11sPathSelectionProtocol)i.ReadNtohU32 ();
+  // Active Path Metric ID:
+  m_APSMId = (dot11sPathSelectionMetric)i.ReadNtohU32 ();
+  // Congestion Control Mode ID:
+  m_CCMId  = (dot11sCongestionControlMode)i.ReadU32 ();
+  // Channel Precedence:
+  m_CP     = (dot11sChannelPrecedence)i.ReadU32 ();
+  i = m_meshCap.Deserialize (i);
+  return i;
 
 
 }
@@ -148,25 +147,25 @@ MeshConfigurationElement::Deserialize (Buffer::Iterator i)
 void
 MeshConfigurationElement::SetRouting(dot11sPathSelectionProtocol routingId)
 {
-	m_APSId =  routingId ;
+  m_APSId  =  routingId;
 }
 
 void
 MeshConfigurationElement::SetMetric(dot11sPathSelectionMetric metricId)
 {
-	m_APSMId =  metricId;
+  m_APSMId =  metricId;
 }
 
 bool
 MeshConfigurationElement::IsHWMP()
 {
-	return (m_APSId == PROTOCOL_HWMP);
+  return (m_APSId == PROTOCOL_HWMP);
 }
 
 bool
 MeshConfigurationElement::IsAirtime()
 {
-	return (m_APSMId  == METRIC_AIRTIME);
+  return (m_APSMId  == METRIC_AIRTIME);
 }
 
 dot11sMeshCapability const& MeshConfigurationElement::MeshCapability()
diff --git a/src/devices/wifi/mesh-configuration-element.h b/src/devices/wifi/mesh-configuration-element.h
index 102c5780b..32b61d120 100644
--- a/src/devices/wifi/mesh-configuration-element.h
+++ b/src/devices/wifi/mesh-configuration-element.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -20,18 +20,17 @@
  */
 
 
-#ifndef	MESH_CONFIGURATION_H
-#define	MESH_CONFIGURATION_H
+#ifndef MESH_CONFIGURATION_H
+#define MESH_CONFIGURATION_H
 
-#include	<stdint.h>
-#include	"ns3/buffer.h"
+#include <stdint.h>
+#include "ns3/buffer.h"
 #include "dot11s-codes.h"
 
-namespace ns3
-{
-  /**
-   * \ingroup mesh
-   */
+namespace ns3 {
+/**
+ * \ingroup mesh
+ */
 enum dot11sPathSelectionProtocol
 {
   PROTOCOL_HWMP = 0x000fac00,
@@ -56,7 +55,7 @@ enum dot11sCongestionControlMode
 /**
  * \ingroup mesh
  */
-enum dot11sChannelPrecedence 
+enum dot11sChannelPrecedence
 {
   CHANNEL_PRECEDENCE_OFF = 0x000fac00,
 };
@@ -66,18 +65,18 @@ enum dot11sChannelPrecedence
  */
 class dot11sMeshCapability
 {
-  public:
+public:
   dot11sMeshCapability();
-  uint32_t		GetSerializedSize () const;
-	Buffer::Iterator	Serialize (Buffer::Iterator i) const;
-	Buffer::Iterator	Deserialize (Buffer::Iterator i);
+  uint32_t  GetSerializedSize () const;
+  Buffer::Iterator Serialize (Buffer::Iterator i) const;
+  Buffer::Iterator Deserialize (Buffer::Iterator i);
   bool acceptPeerLinks;
   bool MDAEnabled;
   bool forwarding;
   bool beaconTimingReport;
   bool TBTTAdjustment;
   bool powerSaveLevel;
-  private:
+private:
   bool Is(uint16_t cap,uint8_t n) const;
 };
 
@@ -86,31 +85,33 @@ class dot11sMeshCapability
  */
 class MeshConfigurationElement
 {
-	public:
-	MeshConfigurationElement();
-	void			SetRouting(dot11sPathSelectionProtocol routingId);
-	void			SetMetric(dot11sPathSelectionMetric metricId);
-	bool			IsHWMP();
-	bool			IsAirtime();
+public:
+  MeshConfigurationElement();
+  void   SetRouting(dot11sPathSelectionProtocol routingId);
+  void   SetMetric(dot11sPathSelectionMetric metricId);
+  bool   IsHWMP();
+  bool   IsAirtime();
 
   dot11sMeshCapability const& MeshCapability();
 
-	uint32_t		GetSerializedSize () const;
-	Buffer::Iterator	Serialize (Buffer::Iterator i) const;
-	Buffer::Iterator	Deserialize (Buffer::Iterator i);
-	// TODO: Release and fill other fields in configuration
-	// element
-	private:
-		static uint8_t ElementId() { return (uint8_t)IE11S_MESH_CONFIGURATION; }
-		/** Active Path Selection Protocol ID */
-		dot11sPathSelectionProtocol	m_APSId;
-		/** Active Path Metric ID */
-		dot11sPathSelectionMetric	  m_APSMId;
-		/** Congestion Control Mode ID */
-		dot11sCongestionControlMode	m_CCMId;
-		/* Channel Precedence */
-		dot11sChannelPrecedence	m_CP;
-		dot11sMeshCapability	m_meshCap;
+  uint32_t  GetSerializedSize () const;
+  Buffer::Iterator Serialize (Buffer::Iterator i) const;
+  Buffer::Iterator Deserialize (Buffer::Iterator i);
+  // TODO: Release and fill other fields in configuration
+  // element
+private:
+  static uint8_t ElementId() {
+    return (uint8_t)IE11S_MESH_CONFIGURATION;
+  }
+  /** Active Path Selection Protocol ID */
+  dot11sPathSelectionProtocol m_APSId;
+  /** Active Path Metric ID */
+  dot11sPathSelectionMetric   m_APSMId;
+  /** Congestion Control Mode ID */
+  dot11sCongestionControlMode m_CCMId;
+  /* Channel Precedence */
+  dot11sChannelPrecedence m_CP;
+  dot11sMeshCapability m_meshCap;
 };
 } //name space NS3
 #endif
diff --git a/src/devices/wifi/mesh-mgt-headers.cc b/src/devices/wifi/mesh-mgt-headers.cc
index cbbfea4ff..12981c1f8 100644
--- a/src/devices/wifi/mesh-mgt-headers.cc
+++ b/src/devices/wifi/mesh-mgt-headers.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -29,69 +29,69 @@
 NS_LOG_COMPONENT_DEFINE("MeshMgtHeaders");
 
 
-namespace ns3
-{/***********************************************************
+namespace ns3 {
+/***********************************************************
  *          Mesh Beacon
  ***********************************************************/
 void
 MgtMeshBeaconHeader::SetMeshConfigurationElement(MeshConfigurationElement mesh_config)
 {
-	m_meshConfig = mesh_config;
+  m_meshConfig = mesh_config;
 }
 
 void
 MgtMeshBeaconHeader::SetWifiBeaconTimingElement(WifiBeaconTimingElement wifi_timing)
 {
-	m_meshTiming = wifi_timing;
+  m_meshTiming = wifi_timing;
 }
 
 MeshConfigurationElement
 MgtMeshBeaconHeader::GetMeshConfigurationElement()
 {
-	return m_meshConfig;
+  return m_meshConfig;
 }
 
 WifiBeaconTimingElement
 MgtMeshBeaconHeader::GetWifiBeaconTimingElement()
 {
-	return m_meshTiming;
+  return m_meshTiming;
 }
 
 uint32_t
 MgtMeshBeaconHeader::GetSerializedSize () const
-{
-	uint32_t size = (
-			  MgtBeaconHeader::GetSerializedSize()
-			+ m_meshConfig.GetSerializedSize()
-			+ m_meshTiming.GetSerializedSize()
-			+ 9 //MSCIE
-			);
-        return size;
-}
+  {
+    uint32_t size = (
+                      MgtBeaconHeader::GetSerializedSize()
+                      + m_meshConfig.GetSerializedSize()
+                      + m_meshTiming.GetSerializedSize()
+                      + 9 //MSCIE
+                    );
+    return size;
+  }
 void
 MgtMeshBeaconHeader::Serialize (Buffer::Iterator start) const
-{
-	//First we pack Beacon:
-  NS_LOG_DEBUG("Serialization beacon");
-	Buffer::Iterator i = start;
-	MgtBeaconHeader::Serialize(i);
-	i.Next(MgtBeaconHeader::GetSerializedSize());
-	i = m_meshConfig.Serialize(i);
-	i = m_meshTiming.Serialize(i);
-	i.Next(9); //MSCIE
-}
+  {
+    //First we pack Beacon:
+    NS_LOG_DEBUG("Serialization beacon");
+    Buffer::Iterator i = start;
+    MgtBeaconHeader::Serialize(i);
+    i.Next (MgtBeaconHeader::GetSerializedSize());
+    i = m_meshConfig.Serialize(i);
+    i = m_meshTiming.Serialize(i);
+    i.Next (9); //MSCIE
+  }
 
 uint32_t
 MgtMeshBeaconHeader::Deserialize (Buffer::Iterator start)
 {
-        NS_LOG_DEBUG("Deserialization beacon");
-	Buffer::Iterator i = start;
-	MgtBeaconHeader::Deserialize(start);
-	i.Next(MgtBeaconHeader::GetSerializedSize());
-	i = m_meshConfig.Deserialize(i);
-	i = m_meshTiming.Deserialize(i);
-	i.Next(9); //MSCIE
-	return i.GetDistanceFrom (start);
+  NS_LOG_DEBUG("Deserialization beacon");
+  Buffer::Iterator i = start;
+  MgtBeaconHeader::Deserialize(start);
+  i.Next (MgtBeaconHeader::GetSerializedSize());
+  i = m_meshConfig.Deserialize(i);
+  i = m_meshTiming.Deserialize(i);
+  i.Next (9); //MSCIE
+  return i.GetDistanceFrom (start);
 }
 
 
@@ -107,185 +107,185 @@ MeshMgtPeerLinkManFrame::MeshMgtPeerLinkManFrame()
 void
 MeshMgtPeerLinkManFrame::SetAid(uint16_t aid)
 {
-	Aid = aid;
+  Aid = aid;
 }
 
 void
 MeshMgtPeerLinkManFrame::SetSupportedRates(SupportedRates rates)
 {
-	Rates = rates;
+  Rates = rates;
 }
 
 void
 MeshMgtPeerLinkManFrame::SetQosField(uint16_t qos)
 {
-	QoS= qos;
+  QoS = qos;
 }
 
 void
 MeshMgtPeerLinkManFrame::SetMeshId(Ssid Id)
 {
-	MeshId = Id;
+  MeshId = Id;
 }
 
 void
 MeshMgtPeerLinkManFrame::SetMeshConfigurationElement(MeshConfigurationElement MeshConf)
 {
-	MeshConfig = MeshConf;
+  MeshConfig = MeshConf;
 }
 
 void
 MeshMgtPeerLinkManFrame::SetPeerLinkManagementElement(PeerLinkManagementElement MeshPeerElement)
 {
-	PeerLinkMan = MeshPeerElement;
+  PeerLinkMan = MeshPeerElement;
 }
 
 uint16_t
 MeshMgtPeerLinkManFrame::GetAid()
 {
-	return Aid;
+  return Aid;
 }
 
 SupportedRates
 MeshMgtPeerLinkManFrame::GetSupportedRates()
 {
-	return Rates;
+  return Rates;
 }
 
 uint16_t
 MeshMgtPeerLinkManFrame::GetQosField()
 {
-	return QoS;
+  return QoS;
 }
 
 Ssid
 MeshMgtPeerLinkManFrame::GetMeshId()
 {
-	return MeshId;
+  return MeshId;
 }
 
 MeshConfigurationElement
 MeshMgtPeerLinkManFrame::GetMeshConfigurationElement()
 {
-	return MeshConfig;
+  return MeshConfig;
 }
 
 PeerLinkManagementElement
 MeshMgtPeerLinkManFrame::GetPeerLinkManagementElement()
 {
-	return PeerLinkMan;
+  return PeerLinkMan;
 }
 
 TypeId
 MeshMgtPeerLinkManFrame::GetTypeId()
 {
-	static TypeId tid = 
-		TypeId ("ns3::MeshMgtPeerLinkManFrame")
-		.SetParent<Header> ()
-		.AddConstructor<MeshMgtPeerLinkManFrame> ()
-		;
-	return tid;
+  static TypeId tid =
+    TypeId ("ns3::MeshMgtPeerLinkManFrame")
+    .SetParent<Header> ()
+    .AddConstructor<MeshMgtPeerLinkManFrame> ()
+    ;
+  return tid;
 }
 
 TypeId
 MeshMgtPeerLinkManFrame::GetInstanceTypeId() const
-{
-	return GetTypeId();
-}
+  {
+    return GetTypeId();
+  }
 
 void
 MeshMgtPeerLinkManFrame::Print(std::ostream &os) const
-{
-	//TODO:fill this method
-}
+  {
+    //TODO:fill this method
+  }
 
 uint32_t
 MeshMgtPeerLinkManFrame::GetSerializedSize() const
-{
-	uint32_t size = 1; //Subtype
-	if(MESH_MGT_HEADER_PEER_CONFIRM == Subtype)
-		size +=2; //AID of remote peer
-	if(MESH_MGT_HEADER_PEER_CLOSE != Subtype)
-	{
-		size += Rates.GetSerializedSize ();
-		size +=2;
-		size += MeshId.GetSerializedSize ();
-		size += MeshConfig.GetSerializedSize ();
-	}
-	size += PeerLinkMan.GetSerializedSize ();
-	return size;
-}
+  {
+    uint32_t size = 1; //Subtype
+    if (MESH_MGT_HEADER_PEER_CONFIRM == Subtype)
+      size += 2; //AID of remote peer
+    if (MESH_MGT_HEADER_PEER_CLOSE != Subtype)
+      {
+        size += Rates.GetSerializedSize ();
+        size += 2;
+        size += MeshId.GetSerializedSize ();
+        size += MeshConfig.GetSerializedSize ();
+      }
+    size += PeerLinkMan.GetSerializedSize ();
+    return size;
+  }
 
 void
 MeshMgtPeerLinkManFrame::Serialize(Buffer::Iterator start) const
-{
-	Buffer::Iterator i = start;
-	i.WriteU8(Subtype); //Like a Category in Standart
-	if(MESH_MGT_HEADER_PEER_CONFIRM == Subtype)
-		
-		i.WriteHtonU16(Aid);
-	if(MESH_MGT_HEADER_PEER_CLOSE != Subtype)
-	{
-		i = Rates.Serialize(i);
-		//now QoS capabilities
-		i.WriteHtonU16(QoS);
-		i = MeshId.Serialize (i);
-		i = MeshConfig.Serialize (i);
-	}
-	i = PeerLinkMan.Serialize (i);
-}
+  {
+    Buffer::Iterator i = start;
+    i.WriteU8(Subtype); //Like a Category in Standart
+    if (MESH_MGT_HEADER_PEER_CONFIRM == Subtype)
+
+      i.WriteHtonU16(Aid);
+    if (MESH_MGT_HEADER_PEER_CLOSE != Subtype)
+      {
+        i = Rates.Serialize (i);
+        //now QoS capabilities
+        i.WriteHtonU16 (QoS);
+        i = MeshId.Serialize (i);
+        i = MeshConfig.Serialize (i);
+      }
+    i = PeerLinkMan.Serialize (i);
+  }
 
 uint32_t
 MeshMgtPeerLinkManFrame::Deserialize(Buffer::Iterator start)
 {
-	Buffer::Iterator i = start;
-	Subtype = i.ReadU8();
-	if(MESH_MGT_HEADER_PEER_CONFIRM == Subtype)
-		Aid = i.ReadNtohU16();
-	if(MESH_MGT_HEADER_PEER_CLOSE != Subtype)
-	{
-		i = Rates.Deserialize(i);
-		QoS = i.ReadNtohU16();
-		i = MeshId.Deserialize (i);
-		i = MeshConfig.Deserialize (i);
-	}
-	i = PeerLinkMan.Deserialize (i);
-	return i.GetDistanceFrom (start);
+  Buffer::Iterator i = start;
+  Subtype = i.ReadU8 ();
+  if (MESH_MGT_HEADER_PEER_CONFIRM == Subtype)
+    Aid = i.ReadNtohU16 ();
+  if (MESH_MGT_HEADER_PEER_CLOSE != Subtype)
+    {
+      i = Rates.Deserialize (i);
+      QoS = i.ReadNtohU16 ();
+      i = MeshId.Deserialize (i);
+      i = MeshConfig.Deserialize (i);
+    }
+  i = PeerLinkMan.Deserialize (i);
+  return i.GetDistanceFrom (start);
 }
 void
 MeshMgtPeerLinkManFrame::SetOpen()
 {
-	Subtype = MESH_MGT_HEADER_PEER_OPEN;
+  Subtype = MESH_MGT_HEADER_PEER_OPEN;
 }
 
 void
 MeshMgtPeerLinkManFrame::SetConfirm()
 {
-	Subtype = MESH_MGT_HEADER_PEER_CONFIRM;
+  Subtype = MESH_MGT_HEADER_PEER_CONFIRM;
 }
 
 void
 MeshMgtPeerLinkManFrame::SetClose()
 {
-	Subtype = MESH_MGT_HEADER_PEER_CLOSE;
+  Subtype = MESH_MGT_HEADER_PEER_CLOSE;
 }
 
 bool
 MeshMgtPeerLinkManFrame::IsOpen()
 {
-	return (Subtype==MESH_MGT_HEADER_PEER_OPEN);
+  return (Subtype == MESH_MGT_HEADER_PEER_OPEN);
 }
 
 bool
 MeshMgtPeerLinkManFrame::IsConfirm()
 {
-	return (Subtype==MESH_MGT_HEADER_PEER_CONFIRM);
+  return (Subtype == MESH_MGT_HEADER_PEER_CONFIRM);
 }
 
 bool
 MeshMgtPeerLinkManFrame::IsClose()
 {
-	return (Subtype==MESH_MGT_HEADER_PEER_CLOSE);
+  return (Subtype == MESH_MGT_HEADER_PEER_CLOSE);
 }
 
 } //namespace NS3
diff --git a/src/devices/wifi/mesh-mgt-headers.h b/src/devices/wifi/mesh-mgt-headers.h
index a0e0d4167..fd93f6879 100644
--- a/src/devices/wifi/mesh-mgt-headers.h
+++ b/src/devices/wifi/mesh-mgt-headers.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -46,75 +46,73 @@ namespace ns3 {
  */
 class MgtMeshBeaconHeader : public MgtBeaconHeader
 {
-	public:
-		void				SetMeshConfigurationElement(MeshConfigurationElement mesh_config);
-		void				SetWifiBeaconTimingElement(WifiBeaconTimingElement wifi_timing);
-		MeshConfigurationElement	GetMeshConfigurationElement();
-		WifiBeaconTimingElement		GetWifiBeaconTimingElement();
-		virtual uint32_t		GetSerializedSize () const;
-		virtual void			Serialize (Buffer::Iterator start) const;
-		virtual uint32_t		Deserialize (Buffer::Iterator start);
-
-	private:
-		MeshConfigurationElement	m_meshConfig;
-		WifiBeaconTimingElement		m_meshTiming;
+public:
+  void    SetMeshConfigurationElement(MeshConfigurationElement mesh_config);
+  void    SetWifiBeaconTimingElement(WifiBeaconTimingElement wifi_timing);
+  MeshConfigurationElement GetMeshConfigurationElement();
+  WifiBeaconTimingElement  GetWifiBeaconTimingElement();
+  virtual uint32_t  GetSerializedSize () const;
+  virtual void   Serialize (Buffer::Iterator start) const;
+  virtual uint32_t  Deserialize (Buffer::Iterator start);
 
+private:
+  MeshConfigurationElement m_meshConfig;
+  WifiBeaconTimingElement  m_meshTiming;
 };
 
 /**
  * \ingroup mesh
  */
-class MeshMgtPeerLinkManFrame :	public Header
+class MeshMgtPeerLinkManFrame : public Header
 {
-	public:
-		MeshMgtPeerLinkManFrame ();
-		void				SetAid(uint16_t aid);
-		void				SetSupportedRates(SupportedRates rates);
-		void				SetQosField(uint16_t qos);
-		void				SetMeshId(Ssid Id);
-		void				SetMeshConfigurationElement(MeshConfigurationElement MeshConf);
-		void				SetPeerLinkManagementElement(PeerLinkManagementElement MeshPeerElement);
+public:
+  MeshMgtPeerLinkManFrame ();
+  void    SetAid(uint16_t aid);
+  void    SetSupportedRates(SupportedRates rates);
+  void    SetQosField(uint16_t qos);
+  void    SetMeshId(Ssid Id);
+  void    SetMeshConfigurationElement(MeshConfigurationElement MeshConf);
+  void    SetPeerLinkManagementElement(PeerLinkManagementElement MeshPeerElement);
 
-		uint16_t			GetAid();
-		SupportedRates			GetSupportedRates();
-		uint16_t			GetQosField();
-		Ssid				GetMeshId();
-		MeshConfigurationElement	GetMeshConfigurationElement();
-		PeerLinkManagementElement	GetPeerLinkManagementElement();
+  uint16_t         GetAid();
+  SupportedRates   GetSupportedRates();
+  uint16_t         GetQosField();
+  Ssid             GetMeshId();
+  MeshConfigurationElement  GetMeshConfigurationElement();
+  PeerLinkManagementElement GetPeerLinkManagementElement();
 
-		static TypeId			GetTypeId();
-		virtual TypeId			GetInstanceTypeId() const;
-		virtual void			Print(std::ostream &os) const;
-		virtual uint32_t		GetSerializedSize() const;
-		virtual void			Serialize(Buffer::Iterator start) const;
-		virtual uint32_t		Deserialize(Buffer::Iterator start);
-		//Subtype defining methods:
-		void				SetOpen();
-		void				SetConfirm();
-		void				SetClose();
+  static  TypeId   GetTypeId();
+  virtual TypeId   GetInstanceTypeId() const;
+  virtual void     Print(std::ostream &os) const;
+  virtual uint32_t GetSerializedSize() const;
+  virtual void     Serialize(Buffer::Iterator start) const;
+  virtual uint32_t Deserialize(Buffer::Iterator start);
+  //Subtype defining methods:
+  void    SetOpen();
+  void    SetConfirm();
+  void    SetClose();
 
-		bool				IsOpen();
-		bool				IsConfirm();
-		bool				IsClose();
+  bool    IsOpen();
+  bool    IsConfirm();
+  bool    IsClose();
 
-	private:
-		uint8_t			Subtype;
-		static const uint8_t	MESH_MGT_HEADER_PEER_OPEN = 1;
-		static const uint8_t	MESH_MGT_HEADER_PEER_CONFIRM = 2;
-		static const uint8_t	MESH_MGT_HEADER_PEER_CLOSE = 3;
-		// Standart is also requires a ReasonCode to be within
-		// PeerLinkClose frame format, but it is present within
-		// PeerLinkManagementElement, so we did not duplicate
-		// it.
-		uint16_t			Aid;		//only in Confirm
-		SupportedRates			Rates;		//only in Open and Confirm
-		uint16_t			QoS;		//only in Open and Confirm
-		Ssid				MeshId;		//only in Open and Confirm
-		MeshConfigurationElement	MeshConfig;	//only in Open and Confirm
-		PeerLinkManagementElement	PeerLinkMan;	//in all types of frames
+private:
+  uint8_t   Subtype;
+  static const uint8_t MESH_MGT_HEADER_PEER_OPEN = 1;
+  static const uint8_t MESH_MGT_HEADER_PEER_CONFIRM = 2;
+  static const uint8_t MESH_MGT_HEADER_PEER_CLOSE = 3;
+  // Standart is also requires a ReasonCode to be within
+  // PeerLinkClose frame format, but it is present within
+  // PeerLinkManagementElement, so we did not duplicate
+  // it.
+  uint16_t   Aid;  //only in Confirm
+  SupportedRates   Rates;  //only in Open and Confirm
+  uint16_t   QoS;  //only in Open and Confirm
+  Ssid    MeshId;  //only in Open and Confirm
+  MeshConfigurationElement MeshConfig; //only in Open and Confirm
+  PeerLinkManagementElement PeerLinkMan; //in all types of frames
 };
 
 }//namespace NS3
 #endif
 
-
diff --git a/src/devices/wifi/mesh-wifi-beacon-timing-element.cc b/src/devices/wifi/mesh-wifi-beacon-timing-element.cc
index 94b381ec0..de3a87d44 100644
--- a/src/devices/wifi/mesh-wifi-beacon-timing-element.cc
+++ b/src/devices/wifi/mesh-wifi-beacon-timing-element.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -26,45 +26,45 @@ namespace ns3 {
  *******************************************/
 WifiBeaconTimingElementUnit::WifiBeaconTimingElementUnit()
 {
-	AID = 0;
-	LastBeacon = 0;
-	BeaconInterval = 0;
+  AID = 0;
+  LastBeacon = 0;
+  BeaconInterval = 0;
 }
 
 void
 WifiBeaconTimingElementUnit::SetAID(uint8_t aid)
 {
-	AID = aid;
+  AID = aid;
 }
 
 void
 WifiBeaconTimingElementUnit::SetLastBeacon(uint16_t last_beacon)
 {
-	LastBeacon = last_beacon;
+  LastBeacon = last_beacon;
 }
 
 void
 WifiBeaconTimingElementUnit::SetBeaconInterval(uint16_t beacon_interval)
 {
-	BeaconInterval = beacon_interval;
+  BeaconInterval = beacon_interval;
 }
 
 uint8_t
 WifiBeaconTimingElementUnit::GetAID()
 {
-	return AID;
+  return AID;
 }
 
 uint16_t
 WifiBeaconTimingElementUnit::GetLastBeacon()
 {
-	return LastBeacon;
+  return LastBeacon;
 }
 
 uint16_t
 WifiBeaconTimingElementUnit::GetBeaconInterval()
 {
-	return BeaconInterval;
+  return BeaconInterval;
 }
 
 /*******************************************
@@ -72,119 +72,119 @@ WifiBeaconTimingElementUnit::GetBeaconInterval()
  *******************************************/
 WifiBeaconTimingElement::WifiBeaconTimingElement()
 {
-	m_maxSize = DEFAULT_MAX_SIZE;
-	m_numOfUnits = 0;
+  m_maxSize = DEFAULT_MAX_SIZE;
+  m_numOfUnits = 0;
 }
 
 NeighboursTimingUnitsList
 WifiBeaconTimingElement::GetNeighboursTimingElementsList()
 {
-	return m_neighbours;
+  return m_neighbours;
 }
 
 void
 WifiBeaconTimingElement::AddNeighboursTimingElementUnit(
-		uint16_t	aid,
-		Time		last_beacon,	//MicroSeconds!
-		Time		beacon_interval	//MicroSeconds!
-		)
+  uint16_t aid,
+  Time  last_beacon, //MicroSeconds!
+  Time  beacon_interval //MicroSeconds!
+)
 {
-	//Firs we lookup if this element already exists
-	for(NeighboursTimingUnitsList::iterator i = m_neighbours.begin(); i!= m_neighbours.end(); i++)
-		if(
-				   ((*i)->GetAID() == AID_TO_U8(aid))
-				&& ((*i)->GetLastBeacon() == TIMESTAMP_TO_U16(last_beacon))
-				&& ((*i)->GetBeaconInterval() == BEACON_INTERVAL_TO_U16(beacon_interval))
-				)
-			return;
-	Ptr<WifiBeaconTimingElementUnit>new_element = Create<WifiBeaconTimingElementUnit>();
-	new_element->SetAID(AID_TO_U8(aid));
-	new_element->SetLastBeacon(TIMESTAMP_TO_U16(last_beacon));
-	new_element->SetBeaconInterval(BEACON_INTERVAL_TO_U16(beacon_interval));
-	m_neighbours.push_back(new_element);
-	m_numOfUnits++;
+  //Firs we lookup if this element already exists
+  for (NeighboursTimingUnitsList::iterator i = m_neighbours.begin(); i!= m_neighbours.end(); i++)
+    if (
+      ((*i)->GetAID() == AID_TO_U8(aid))
+      && ((*i)->GetLastBeacon() == TIMESTAMP_TO_U16(last_beacon))
+      && ((*i)->GetBeaconInterval() == BEACON_INTERVAL_TO_U16(beacon_interval))
+    )
+      return;
+  Ptr<WifiBeaconTimingElementUnit>new_element = Create<WifiBeaconTimingElementUnit>();
+  new_element->SetAID(AID_TO_U8(aid));
+  new_element->SetLastBeacon(TIMESTAMP_TO_U16(last_beacon));
+  new_element->SetBeaconInterval(BEACON_INTERVAL_TO_U16(beacon_interval));
+  m_neighbours.push_back(new_element);
+  m_numOfUnits++;
 }
 
 void
 WifiBeaconTimingElement::DelNeighboursTimingElementUnit(
-		uint16_t	aid,
-		Time		last_beacon,	//MicroSeconds!
-		Time		beacon_interval	//MicroSeconds!
-		)
+  uint16_t aid,
+  Time  last_beacon, //MicroSeconds!
+  Time  beacon_interval //MicroSeconds!
+)
 {
-	for(NeighboursTimingUnitsList::iterator i = m_neighbours.begin(); i!= m_neighbours.end(); i++)
-		if(
-				   ((*i)->GetAID() == AID_TO_U8(aid))
-				&& ((*i)->GetLastBeacon() == TIMESTAMP_TO_U16(last_beacon))
-				&& ((*i)->GetBeaconInterval() == BEACON_INTERVAL_TO_U16(beacon_interval))
-				)
-		{
-			m_neighbours.erase(i);
-			m_numOfUnits--;
-			break;
-		}
+  for (NeighboursTimingUnitsList::iterator i = m_neighbours.begin(); i!= m_neighbours.end(); i++)
+    if (
+      ((*i)->GetAID() == AID_TO_U8(aid))
+      && ((*i)->GetLastBeacon() == TIMESTAMP_TO_U16(last_beacon))
+      && ((*i)->GetBeaconInterval() == BEACON_INTERVAL_TO_U16(beacon_interval))
+    )
+      {
+        m_neighbours.erase(i);
+        m_numOfUnits--;
+        break;
+      }
 
 }
 
 void
 WifiBeaconTimingElement::ClearTimingElement()
 {
-	uint16_t to_delete = 0;
-	uint16_t i;
-	for(NeighboursTimingUnitsList::iterator j = m_neighbours.begin(); j!= m_neighbours.end(); j++)
-	{
-		to_delete++;
-		(*j) = 0;
-	}
-	for(i = 0; i < to_delete; i ++)
-		m_neighbours.pop_back();
-	m_neighbours.clear();
+  uint16_t to_delete = 0;
+  uint16_t i;
+  for (NeighboursTimingUnitsList::iterator j = m_neighbours.begin(); j!= m_neighbours.end(); j++)
+    {
+      to_delete++;
+      (*j) = 0;
+    }
+  for (i = 0; i < to_delete; i ++)
+    m_neighbours.pop_back();
+  m_neighbours.clear();
 
 }
 
 uint32_t
 WifiBeaconTimingElement::GetSerializedSize () const
-{
-	return (2+5*m_numOfUnits > m_maxSize) ? 2+((m_maxSize-2)/5)*5 : 2+5*m_numOfUnits;
-}
+  {
+    return (2+5*m_numOfUnits > m_maxSize) ? 2+((m_maxSize-2)/5)*5 : 2+5*m_numOfUnits;
+  }
 Buffer::Iterator
 WifiBeaconTimingElement::Serialize (Buffer::Iterator i) const
-{
-	uint8_t can_be_written = (2+5*m_numOfUnits > m_maxSize) ? ((m_maxSize-2)/5) : m_numOfUnits;
-	int actually_written = 0;
-	i.WriteU8 (ElementId());
-	i.WriteU8 (can_be_written);
-	for(NeighboursTimingUnitsList::const_iterator j = m_neighbours.begin(); j!= m_neighbours.end(); j++)
-	{
-		i.WriteU8	((*j)->GetAID());
-		i.WriteHtonU16	((*j)->GetLastBeacon());
-		i.WriteHtonU16	((*j)->GetBeaconInterval());
-		actually_written++;
-		if(actually_written > can_be_written)
-			break;
-	}
-	if(can_be_written < m_numOfUnits)
-	{
-		//move written units to the end of our list, so they
-		//can be sent in timing element with next beacon
-		//TODO:swap elements
-		
-	}
-	return i;
-}
+  {
+    uint8_t can_be_written = (2+5*m_numOfUnits > m_maxSize) ? ((m_maxSize-2)/5) : m_numOfUnits;
+    int actually_written = 0;
+    i.WriteU8 (ElementId());
+    i.WriteU8 (can_be_written);
+    for (NeighboursTimingUnitsList::const_iterator j = m_neighbours.begin(); j!= m_neighbours.end(); j++)
+      {
+        i.WriteU8 ((*j)->GetAID());
+        i.WriteHtonU16 ((*j)->GetLastBeacon());
+        i.WriteHtonU16 ((*j)->GetBeaconInterval());
+        actually_written++;
+        if (actually_written > can_be_written)
+          break;
+      }
+    if (can_be_written < m_numOfUnits)
+      {
+        //move written units to the end of our list, so they
+        //can be sent in timing element with next beacon
+        //TODO:swap elements
+
+      }
+    return i;
+  }
 Buffer::Iterator
 WifiBeaconTimingElement::Deserialize (Buffer::Iterator i)
 {
-	NS_ASSERT(ElementId() == i.ReadU8());
-	uint8_t num_to_read = i.ReadU8();
-	for(int j = 0; j < num_to_read; j ++)
-	{		
-		Ptr<WifiBeaconTimingElementUnit> new_element = Create<WifiBeaconTimingElementUnit>();
-		new_element->SetAID(i.ReadU8());
-		new_element->SetLastBeacon(i.ReadNtohU16());
-		new_element->SetBeaconInterval(i.ReadNtohU16());
-		m_neighbours.push_back(new_element);
-	}
-	return i;
+  NS_ASSERT(ElementId() == i.ReadU8());
+  uint8_t num_to_read = i.ReadU8();
+  for (int j = 0; j < num_to_read; j ++)
+    {
+      Ptr<WifiBeaconTimingElementUnit> new_element = Create<WifiBeaconTimingElementUnit>();
+      new_element->SetAID(i.ReadU8());
+      new_element->SetLastBeacon(i.ReadNtohU16());
+      new_element->SetBeaconInterval(i.ReadNtohU16());
+      m_neighbours.push_back(new_element);
+    }
+  return i;
 };
 } //namespace ns3
diff --git a/src/devices/wifi/mesh-wifi-beacon-timing-element.h b/src/devices/wifi/mesh-wifi-beacon-timing-element.h
index 32209f8b8..2f66b9d30 100644
--- a/src/devices/wifi/mesh-wifi-beacon-timing-element.h
+++ b/src/devices/wifi/mesh-wifi-beacon-timing-element.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -19,100 +19,101 @@
  */
 
 
-#ifndef	WIFI_TIMING_ELEMENT_H
-#define	WIFI_TIMING_ELEMENT_H
+#ifndef WIFI_TIMING_ELEMENT_H
+#define WIFI_TIMING_ELEMENT_H
 
-#include	<stdint.h>
-#include	"ns3/buffer.h"
-#include	"ns3/nstime.h"
-#include	<list>
+#include <stdint.h>
+#include "ns3/buffer.h"
+#include "ns3/nstime.h"
+#include <list>
 #include "dot11s-codes.h"
-namespace ns3
-{
+namespace ns3 {
 /**
  * \ingroup mesh
  */
 class WifiBeaconTimingElementUnit : public RefCountBase
 {
-	public:
-		WifiBeaconTimingElementUnit();
-		void	SetAID(uint8_t aid);
-		void	SetLastBeacon(uint16_t last_beacon);
-		void	SetBeaconInterval(uint16_t beacon_interval);
+public:
+  WifiBeaconTimingElementUnit();
+  void SetAID(uint8_t aid);
+  void SetLastBeacon(uint16_t last_beacon);
+  void SetBeaconInterval(uint16_t beacon_interval);
 
-		uint8_t	GetAID();
-		uint16_t	GetLastBeacon();
-		uint16_t	GetBeaconInterval();
-	private:
-		//Least significant octet of AID:
-		uint8_t	AID;
-		//Last time we received a beacon in accordance with a
-		//local TSF measured in 256 microseconds unit:
-		uint16_t	LastBeacon;
-		//Beacon interval of remote mesh point:
-		uint16_t	BeaconInterval;
+  uint8_t GetAID();
+  uint16_t GetLastBeacon();
+  uint16_t GetBeaconInterval();
+private:
+  //Least significant octet of AID:
+  uint8_t AID;
+  //Last time we received a beacon in accordance with a
+  //local TSF measured in 256 microseconds unit:
+  uint16_t LastBeacon;
+  //Beacon interval of remote mesh point:
+  uint16_t BeaconInterval;
 };
 /**
  * \ingroup mesh
  * This type is a list of timing elements obtained from neigbours with their beacons:
  */
-typedef Ptr<WifiBeaconTimingElementUnit>		WifiBeaconTimingElementPointer;
+typedef Ptr<WifiBeaconTimingElementUnit>  WifiBeaconTimingElementPointer;
 
 /**
  * \ingroup mesh
  */
-typedef std::list<WifiBeaconTimingElementPointer>	NeighboursTimingUnitsList;
+typedef std::list<WifiBeaconTimingElementPointer> NeighboursTimingUnitsList;
 
 /**
  * \ingroup mesh
  */
 class WifiBeaconTimingElement
 {
-	public:
-		WifiBeaconTimingElement();
-		//This methods are needed for beacon collision
-		//avoidance module:
-		NeighboursTimingUnitsList
-					GetNeighboursTimingElementsList();
-		//The arguments of the following methods are different
-		//from internalBeaconTimingElementUnint. This was made
-		//for better communication with peer manager.
-		//BeaconTimingElement class should convert it into
-		//proper types:
-		void			AddNeighboursTimingElementUnit(
-				uint16_t	aid,
-				Time		last_beacon,	//MicroSeconds!
-				Time		beacon_interval	//MicroSeconds!
-				);
-		void			DelNeighboursTimingElementUnit(
-				uint16_t	aid,
-				Time		last_beacon,	//MicroSeconds!
-				Time		beacon_interval	//MicroSeconds!
-				);
-		void			ClearTimingElement();
-		uint16_t TIMESTAMP_TO_U16(Time x)
-		{
-			return ((uint16_t)((x.GetMicroSeconds() >> 8)&0xffff));
-		};
-		uint16_t BEACON_INTERVAL_TO_U16(Time x)
-		{
-			return ((uint16_t)(x.GetMicroSeconds() >>10)&0xffff);
-		};
-		uint8_t AID_TO_U8(uint16_t x)
-		{
-			return (uint8_t)(x&0xff);
-		};
-		//Serialize-deserialize methods:
-		uint32_t		GetSerializedSize () const;
-		Buffer::Iterator	Serialize (Buffer::Iterator i) const;
-		Buffer::Iterator	Deserialize (Buffer::Iterator i);
-	private:
-		static uint8_t ElementId() { return (uint8_t)IE11S_BEACON_TIMING; }
-		NeighboursTimingUnitsList		m_neighbours;
-		//The maximum size of this element:
-		const static uint16_t	DEFAULT_MAX_SIZE = 255*5 +2;
-		uint16_t		m_maxSize;
-		uint16_t		m_numOfUnits;
+public:
+  WifiBeaconTimingElement();
+  //This methods are needed for beacon collision
+  //avoidance module:
+  NeighboursTimingUnitsList
+  GetNeighboursTimingElementsList();
+  //The arguments of the following methods are different
+  //from internalBeaconTimingElementUnint. This was made
+  //for better communication with peer manager.
+  //BeaconTimingElement class should convert it into
+  //proper types:
+  void   AddNeighboursTimingElementUnit(
+    uint16_t aid,
+    Time  last_beacon, //MicroSeconds!
+    Time  beacon_interval //MicroSeconds!
+  );
+  void   DelNeighboursTimingElementUnit(
+    uint16_t aid,
+    Time  last_beacon, //MicroSeconds!
+    Time  beacon_interval //MicroSeconds!
+  );
+  void   ClearTimingElement();
+  uint16_t TIMESTAMP_TO_U16(Time x)
+  {
+    return ((uint16_t)((x.GetMicroSeconds() >> 8)&0xffff));
+  };
+  uint16_t BEACON_INTERVAL_TO_U16(Time x)
+  {
+    return ((uint16_t)(x.GetMicroSeconds() >>10)&0xffff);
+  };
+  uint8_t AID_TO_U8(uint16_t x)
+  {
+    return (uint8_t)(x&0xff);
+  };
+  //Serialize-deserialize methods:
+  uint32_t  GetSerializedSize () const;
+  Buffer::Iterator Serialize (Buffer::Iterator i) const;
+  Buffer::Iterator Deserialize (Buffer::Iterator i);
+private:
+  static uint8_t ElementId() {
+    return (uint8_t)IE11S_BEACON_TIMING;
+  }
+  NeighboursTimingUnitsList  m_neighbours;
+  //The maximum size of this element:
+  const static uint16_t DEFAULT_MAX_SIZE = 255*5 +2;
+  uint16_t  m_maxSize;
+  uint16_t  m_numOfUnits;
 };
 }//namespace ns3
 #endif
diff --git a/src/devices/wifi/mesh-wifi-mac-header.cc b/src/devices/wifi/mesh-wifi-mac-header.cc
index cb19daaa2..b1f106165 100644
--- a/src/devices/wifi/mesh-wifi-mac-header.cc
+++ b/src/devices/wifi/mesh-wifi-mac-header.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -26,20 +26,20 @@
 namespace ns3 {
 
 /***********************************************************
- * 	Here Mesh Mac Header functionality is defined.
+ *  Here Mesh Mac Header functionality is defined.
  ***********************************************************/
-TypeId 
+TypeId
 WifiMeshHeader::GetTypeId ()
 {
   static TypeId tid = TypeId ("ns3::WifiMeshHeader")
-    .SetParent<Header> ()
-    .AddConstructor<WifiMeshHeader> ()
-    ;
+                      .SetParent<Header> ()
+                      .AddConstructor<WifiMeshHeader> ()
+                      ;
   return tid;
 }
 
 WifiMeshHeader::WifiMeshHeader()
-	:m_meshFlags(0)
+    :m_meshFlags(0)
 {
 }
 
@@ -47,136 +47,136 @@ WifiMeshHeader::~WifiMeshHeader()
 {
 }
 
-TypeId 
+TypeId
 WifiMeshHeader::GetInstanceTypeId () const
-{
-  return GetTypeId ();
-}
+  {
+    return GetTypeId ();
+  }
 
 void
 WifiMeshHeader::SetAddr5 (Mac48Address address)
 {
-	m_addr5 = address;
+  m_addr5 = address;
 }
 
 void
 WifiMeshHeader::SetAddr6 (Mac48Address address)
 {
-	m_addr6 = address;
+  m_addr6 = address;
 }
 
 void
 WifiMeshHeader::SetAddr7 (Mac48Address address)
 {
-	m_addr7 = address;
+  m_addr7 = address;
 }
 
 Mac48Address
 WifiMeshHeader::GetAddr5 ()
 {
-	return m_addr5;
+  return m_addr5;
 }
 
 Mac48Address
 WifiMeshHeader::GetAddr6 ()
 {
-	return m_addr6;
+  return m_addr6;
 }
 
 Mac48Address
 WifiMeshHeader::GetAddr7 ()
 {
-	return m_addr7;
+  return m_addr7;
 }
 
 void
 WifiMeshHeader::SetMeshSeqno (uint32_t seqno)
 {
-	m_meshSeqno = seqno;
+  m_meshSeqno = seqno;
 }
 
 uint32_t
 WifiMeshHeader::GetMeshSeqno ()
 {
-	return m_meshSeqno;
+  return m_meshSeqno;
 }
 
 void
 WifiMeshHeader::SetMeshTtl (uint8_t TTL)
 {
-	m_meshTtl = TTL;
+  m_meshTtl = TTL;
 }
 
 uint8_t
 WifiMeshHeader::GetMeshTtl ()
 {
-	return m_meshTtl;
+  return m_meshTtl;
 }
 
 void
 WifiMeshHeader::SetAddressExt (uint8_t num_of_addresses)
 {
-	if (num_of_addresses > 3)
-		return;
-	m_meshFlags = 0xc0 | (num_of_addresses << 6);
+  if (num_of_addresses > 3)
+    return;
+  m_meshFlags = 0xc0 | (num_of_addresses << 6);
 }
 
 uint8_t
 WifiMeshHeader::GetAddressExt ()
 {
-	return ((0xc0 & m_meshFlags) >> 6);
+  return ((0xc0 & m_meshFlags) >> 6);
 }
 
 
 uint32_t
 WifiMeshHeader::GetSerializedSize () const
-{
-	return 6 + ((0xc0 & m_meshFlags) >> 6)*6;
-}
+  {
+    return 6 + ((0xc0 & m_meshFlags) >> 6)*6;
+  }
 
 void
 WifiMeshHeader::Serialize (Buffer::Iterator start) const
-{
-	Buffer::Iterator i = start;
-	i.WriteU8(m_meshFlags);
-	i.WriteU8(m_meshTtl);
-	i.WriteU32(m_meshSeqno);
-	uint8_t addresses_to_add = (m_meshFlags & 0xc0) >> 6;
-	//Writing Address extensions:
-	if(addresses_to_add > 0)
-		WriteTo (i, m_addr5);
-	if(addresses_to_add > 1)
-		WriteTo (i, m_addr6);
-	if(addresses_to_add > 2)
-		WriteTo (i, m_addr7);
-}
+  {
+    Buffer::Iterator i = start;
+    i.WriteU8 (m_meshFlags);
+    i.WriteU8 (m_meshTtl);
+    i.WriteU32 (m_meshSeqno);
+    uint8_t addresses_to_add = (m_meshFlags & 0xc0) >> 6;
+    //Writing Address extensions:
+    if (addresses_to_add > 0)
+      WriteTo (i, m_addr5);
+    if (addresses_to_add > 1)
+      WriteTo (i, m_addr6);
+    if (addresses_to_add > 2)
+      WriteTo (i, m_addr7);
+  }
 
 uint32_t
 WifiMeshHeader::Deserialize (Buffer::Iterator start)
 {
-	Buffer::Iterator i = start;
-	uint8_t addresses_to_read = 0;
-	m_meshFlags = i.ReadU8();
-	m_meshTtl = i.ReadU8();
-	m_meshSeqno = i.ReadU32();
-	addresses_to_read = (m_meshFlags & 0xc0) >> 6;
-	if(addresses_to_read > 0)
-		ReadFrom (i, m_addr5);
-	if(addresses_to_read > 1)
-		ReadFrom (i, m_addr6);
-	if(addresses_to_read > 2)
-		ReadFrom (i, m_addr7);
-	return i.GetDistanceFrom(start);
+  Buffer::Iterator i = start;
+  uint8_t addresses_to_read = 0;
+  m_meshFlags = i.ReadU8();
+  m_meshTtl = i.ReadU8();
+  m_meshSeqno = i.ReadU32();
+  addresses_to_read = (m_meshFlags & 0xc0) >> 6;
+  if (addresses_to_read > 0)
+    ReadFrom (i, m_addr5);
+  if (addresses_to_read > 1)
+    ReadFrom (i, m_addr6);
+  if (addresses_to_read > 2)
+    ReadFrom (i, m_addr7);
+  return i.GetDistanceFrom(start);
 }
 void
 WifiMeshHeader::Print (std::ostream &os) const
-{
-	os << "flags" << m_meshFlags
-		<< "ttl" << m_meshTtl
-		<< "seqno" << m_meshSeqno;
-}
+  {
+    os << "flags" << m_meshFlags
+    << "ttl" << m_meshTtl
+    << "seqno" << m_meshSeqno;
+  }
 /**********************************************************
- * 		MultihopActionFrame
+ *   MultihopActionFrame
  **********************************************************/
 WifiMeshMultihopActionHeader::WifiMeshMultihopActionHeader ()
 {
@@ -188,175 +188,175 @@ WifiMeshMultihopActionHeader::~WifiMeshMultihopActionHeader ()
 
 void
 WifiMeshMultihopActionHeader::SetAction(
-		enum WifiMeshMultihopActionHeader::CategoryValue type,
-		WifiMeshMultihopActionHeader::ACTION_VALUE action)
+  enum WifiMeshMultihopActionHeader::CategoryValue type,
+  WifiMeshMultihopActionHeader::ACTION_VALUE action)
 {
-	switch(type)
-	{
-		case MESH_PEER_LINK_MGT:
-			m_category = 4;
-			switch (action.peerLink)
-			{
-				case PEER_LINK_OPEN:
-					m_actionValue = 0;
-					break;
-				case PEER_LINK_CONFIRM:
-					m_actionValue = 1;
-					break;
-				case PEER_LINK_CLOSE:
-					m_actionValue = 2;
-					break;
-			};
-			break;
-		case MESH_LINK_METRIC:
-			m_category = 5;
-			break;
-		case MESH_PATH_SELECTION:
-			m_category = 6;
-			switch(action.pathSelection)
-			{
-				case PATH_REQUEST:
-					m_actionValue = 0;
-					break;
-				case PATH_REPLY:
-					m_actionValue = 1;
-					break;
-				case PATH_ERROR:
-					m_actionValue = 2;
-					break;
-				case ROOT_ANNOUNCEMENT:
-					m_actionValue = 3;
-					break;
-			};
-			break;
-		case MESH_INTERWORK_ACTION:
-			m_category = 7;
-			break;
-		case MESH_RESOURCE_COORDINATION:
-			m_category = 8;
-			break;
-	};
+  switch (type)
+    {
+    case MESH_PEER_LINK_MGT:
+      m_category = 4;
+      switch (action.peerLink)
+        {
+        case PEER_LINK_OPEN:
+          m_actionValue = 0;
+          break;
+        case PEER_LINK_CONFIRM:
+          m_actionValue = 1;
+          break;
+        case PEER_LINK_CLOSE:
+          m_actionValue = 2;
+          break;
+        };
+      break;
+    case MESH_LINK_METRIC:
+      m_category = 5;
+      break;
+    case MESH_PATH_SELECTION:
+      m_category = 6;
+      switch (action.pathSelection)
+        {
+        case PATH_REQUEST:
+          m_actionValue = 0;
+          break;
+        case PATH_REPLY:
+          m_actionValue = 1;
+          break;
+        case PATH_ERROR:
+          m_actionValue = 2;
+          break;
+        case ROOT_ANNOUNCEMENT:
+          m_actionValue = 3;
+          break;
+        };
+      break;
+    case MESH_INTERWORK_ACTION:
+      m_category = 7;
+      break;
+    case MESH_RESOURCE_COORDINATION:
+      m_category = 8;
+      break;
+    };
 }
 
 enum WifiMeshMultihopActionHeader::CategoryValue
 WifiMeshMultihopActionHeader::GetCategory()
 {
-	switch(m_category)
-	{
-		case 4:
-			return MESH_PEER_LINK_MGT;
-		case 5:
-			return MESH_LINK_METRIC;
-		case 6:
-			return MESH_PATH_SELECTION;
-		case 7:
-			return MESH_INTERWORK_ACTION;
-		case 8:
-			return MESH_RESOURCE_COORDINATION;
-		default:
-			NS_ASSERT(false);
-			return MESH_PEER_LINK_MGT;
-	}
+  switch (m_category)
+    {
+    case 4:
+      return MESH_PEER_LINK_MGT;
+    case 5:
+      return MESH_LINK_METRIC;
+    case 6:
+      return MESH_PATH_SELECTION;
+    case 7:
+      return MESH_INTERWORK_ACTION;
+    case 8:
+      return MESH_RESOURCE_COORDINATION;
+    default:
+      NS_ASSERT(false);
+      return MESH_PEER_LINK_MGT;
+    }
 }
 
 WifiMeshMultihopActionHeader::ACTION_VALUE
 WifiMeshMultihopActionHeader::GetAction()
 {
-	ACTION_VALUE retval;
-	switch(m_category)
-	{
-		case 4:
-			//MESH_PEER_LINK_MGT;
-			switch(m_actionValue)
-			{
-				case 0:
-					retval.peerLink = PEER_LINK_OPEN;
-					return retval;
-				case 1:
-					retval.peerLink = PEER_LINK_CONFIRM;
-					return retval;
-				case 2:
-					retval.peerLink = PEER_LINK_CLOSE;
-					return retval;
-				default:
-					NS_ASSERT(false);
-					return retval;
+  ACTION_VALUE retval;
+  switch (m_category)
+    {
+    case 4:
+      //MESH_PEER_LINK_MGT;
+      switch (m_actionValue)
+        {
+        case 0:
+          retval.peerLink = PEER_LINK_OPEN;
+          return retval;
+        case 1:
+          retval.peerLink = PEER_LINK_CONFIRM;
+          return retval;
+        case 2:
+          retval.peerLink = PEER_LINK_CLOSE;
+          return retval;
+        default:
+          NS_ASSERT(false);
+          return retval;
 
-			}
-		case 5:
-			//MESH_LINK_METRIC;
-		case 6:
-			//MESH_PATH_SELECTION;
-			switch(m_actionValue)
-			{
-				case 0:
-					retval.pathSelection = PATH_REQUEST;
-					return retval;
-				case 1:
-					retval.pathSelection = PATH_REPLY;
-					return retval;
-				case 2:
-					retval.pathSelection = PATH_ERROR;
-					return retval;
-				case 3:
-					retval.pathSelection = ROOT_ANNOUNCEMENT;
-					return retval;
-				default:
-					NS_ASSERT(false);
-					return retval;
-			}
+        }
+    case 5:
+      //MESH_LINK_METRIC;
+    case 6:
+      //MESH_PATH_SELECTION;
+      switch (m_actionValue)
+        {
+        case 0:
+          retval.pathSelection = PATH_REQUEST;
+          return retval;
+        case 1:
+          retval.pathSelection = PATH_REPLY;
+          return retval;
+        case 2:
+          retval.pathSelection = PATH_ERROR;
+          return retval;
+        case 3:
+          retval.pathSelection = ROOT_ANNOUNCEMENT;
+          return retval;
+        default:
+          NS_ASSERT(false);
+          return retval;
+        }
 
-		case 7:
-			//MESH_INTERWORK_ACTION;
-		case 8:
-			//MESH_RESOURCE_COORDINATION;
-		default:
-			NS_ASSERT(false);
-			return retval;
-	}
+    case 7:
+      //MESH_INTERWORK_ACTION;
+    case 8:
+      //MESH_RESOURCE_COORDINATION;
+    default:
+      NS_ASSERT(false);
+      return retval;
+    }
 }
 
 TypeId
 WifiMeshMultihopActionHeader::GetTypeId ()
 {
-	static TypeId tid = TypeId ("ns3::WifiMeshMultihopActionHeader")
-		.SetParent<Header> ()
-		.AddConstructor<WifiMeshMultihopActionHeader> ()
-		;
-	return tid;
+  static TypeId tid = TypeId ("ns3::WifiMeshMultihopActionHeader")
+                      .SetParent<Header> ()
+                      .AddConstructor<WifiMeshMultihopActionHeader> ()
+                      ;
+  return tid;
 }
 
 TypeId
 WifiMeshMultihopActionHeader::GetInstanceTypeId () const
-{
-	return GetTypeId();
-}
+  {
+    return GetTypeId();
+  }
 
 void
 WifiMeshMultihopActionHeader::Print (std::ostream &os) const
-{
-}
+  {
+  }
 
 uint32_t
 WifiMeshMultihopActionHeader::GetSerializedSize () const
-{
-	return 2;
-}
+  {
+    return 2;
+  }
 
 void
 WifiMeshMultihopActionHeader::Serialize (Buffer::Iterator start) const
-{
-	start.WriteU8(m_category);
-	start.WriteU8(m_actionValue);
-}
+  {
+    start.WriteU8(m_category);
+    start.WriteU8(m_actionValue);
+  }
 
 uint32_t
 WifiMeshMultihopActionHeader::Deserialize (Buffer::Iterator start)
 {
-	Buffer::Iterator i = start;
-	m_category = i.ReadU8();
-	m_actionValue = i.ReadU8();
-	return i.GetDistanceFrom(start);
+  Buffer::Iterator i = start;
+  m_category = i.ReadU8 ();
+  m_actionValue = i.ReadU8 ();
+  return i.GetDistanceFrom (start);
 }
 
 } // namespace ns3
diff --git a/src/devices/wifi/mesh-wifi-mac-header.h b/src/devices/wifi/mesh-wifi-mac-header.h
index 16e56508b..823406474 100644
--- a/src/devices/wifi/mesh-wifi-mac-header.h
+++ b/src/devices/wifi/mesh-wifi-mac-header.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -33,39 +33,39 @@ namespace ns3 {
  */
 class WifiMeshHeader : public Header //7.1.3.5b
 {
-	public:
-		WifiMeshHeader ();
-		~WifiMeshHeader ();
-		static TypeId GetTypeId ();
-		virtual TypeId GetInstanceTypeId () const;
-		virtual void Print (std::ostream &os) const;
+public:
+  WifiMeshHeader ();
+  ~WifiMeshHeader ();
+  static TypeId GetTypeId ();
+  virtual TypeId GetInstanceTypeId () const;
+  virtual void Print (std::ostream &os) const;
 
-		void			SetAddr5 (Mac48Address address);
-		void			SetAddr6 (Mac48Address address);
-		void			SetAddr7 (Mac48Address address);
-		Mac48Address		GetAddr5 ();
-		Mac48Address		GetAddr6 ();
-		Mac48Address		GetAddr7 ();
+  void   SetAddr5 (Mac48Address address);
+  void   SetAddr6 (Mac48Address address);
+  void   SetAddr7 (Mac48Address address);
+  Mac48Address  GetAddr5 ();
+  Mac48Address  GetAddr6 ();
+  Mac48Address  GetAddr7 ();
 
-		void			SetMeshSeqno (uint32_t seqno);
-		uint32_t		GetMeshSeqno ();
+  void   SetMeshSeqno (uint32_t seqno);
+  uint32_t  GetMeshSeqno ();
 
-		void			SetMeshTtl (uint8_t TTL);
-		uint8_t		GetMeshTtl ();
+  void   SetMeshTtl (uint8_t TTL);
+  uint8_t  GetMeshTtl ();
 
-		void			SetAddressExt (uint8_t num_of_addresses);
-		uint8_t		GetAddressExt ();
+  void   SetAddressExt (uint8_t num_of_addresses);
+  uint8_t  GetAddressExt ();
 
-		virtual uint32_t	GetSerializedSize () const;
-		virtual void		Serialize (Buffer::Iterator start) const;
-		virtual uint32_t	Deserialize (Buffer::Iterator start);
-	private:
-		uint8_t	m_meshFlags;
-		uint8_t	m_meshTtl;
-		uint32_t	m_meshSeqno;
-		Mac48Address	m_addr5;
-		Mac48Address	m_addr6;
-		Mac48Address	m_addr7;
+  virtual uint32_t GetSerializedSize () const;
+  virtual void  Serialize (Buffer::Iterator start) const;
+  virtual uint32_t Deserialize (Buffer::Iterator start);
+private:
+  uint8_t  m_meshFlags;
+  uint8_t  m_meshTtl;
+  uint32_t m_meshSeqno;
+  Mac48Address m_addr5;
+  Mac48Address m_addr6;
+  Mac48Address m_addr7;
 };
 
 /**
@@ -73,79 +73,79 @@ class WifiMeshHeader : public Header //7.1.3.5b
  */
 class WifiMeshMultihopActionHeader : public Header //7.2.3.14
 {
-	//Multichop action frame consists of Mesh header, Action, and
-	//the last information. Mesh header is present within all data
-	//frames and multihop action frames, so Mesh header is a
-	//separate structure. Each MultihopAction frames (frames like
-	//PREQ, PREP and other) start form Category field and Action
-	//value field, so the Multihop Action Frame should containt
-	//three fields: Category, Action Value;
-	public:
-		WifiMeshMultihopActionHeader ();
-		~WifiMeshMultihopActionHeader ();
-		enum CategoryValue //table 7-24 staring from 4
-		{
-			MESH_PEER_LINK_MGT =4,
-			MESH_LINK_METRIC,
-			MESH_PATH_SELECTION,
-			MESH_INTERWORK_ACTION,
-			MESH_RESOURCE_COORDINATION,
-		};
-		enum PeerLinkMgtActionValue
-		{
-			PEER_LINK_OPEN = 0,
-			PEER_LINK_CONFIRM,
-			PEER_LINK_CLOSE,
-		};
-		enum LinkMetricActionValue
-		{
-			LINK_METRIC_REQUEST = 0,
-			LINK_METRIC_REPORT,
-		};
-		enum PathSelectionActionValue
-		{
-			PATH_REQUEST = 0,
-			PATH_REPLY,
-			PATH_ERROR,
-			ROOT_ANNOUNCEMENT,
-		};
-		enum InterworkActionValue
-		{
-			PORTAL_ANNOUNCEMENT = 0,
-		};
-		enum ResourceCoordinationActionValue
-		{
-			CONGESTION_CONTROL_NOTIFICATION = 0,
-			MDA_SETUP_REQUEST,
-			MDA_SETUP_REPLY,
-			MDAOP_ADVERTISMENT_REQUEST,
-			MDAOP_ADVERTISMENTS,
-			MDAOP_SET_TEARDOWN,
-			BEACON_TIMING_REQUEST,
-			BEACON_TIMING_RESPONSE,
-			TBTT_ADJASTMENT_REQUEST,
-			MESH_CHANNEL_SWITCH_ANNOUNCEMENT,
-		};
-		typedef union
-		{
-			enum PeerLinkMgtActionValue		peerLink;
-			enum LinkMetricActionValue		linkMetrtic;
-			enum PathSelectionActionValue		pathSelection;
-			enum InterworkActionValue		interwork;
-			enum ResourceCoordinationActionValue	resourceCoordination;
-		} ACTION_VALUE;
-		void			SetAction(enum CategoryValue type,ACTION_VALUE action);
-		enum CategoryValue	GetCategory();
-		ACTION_VALUE		GetAction();
-		static TypeId		GetTypeId ();
-		virtual	TypeId		GetInstanceTypeId () const;
-		virtual void		Print (std::ostream &os) const;
-		virtual uint32_t	GetSerializedSize () const;
-		virtual void		Serialize (Buffer::Iterator start) const;
-		virtual uint32_t	Deserialize (Buffer::Iterator start);
-	private:
-		uint8_t	m_category;
-		uint8_t	m_actionValue;
+  //Multichop action frame consists of Mesh header, Action, and
+  //the last information. Mesh header is present within all data
+  //frames and multihop action frames, so Mesh header is a
+  //separate structure. Each MultihopAction frames (frames like
+  //PREQ, PREP and other) start form Category field and Action
+  //value field, so the Multihop Action Frame should containt
+  //three fields: Category, Action Value;
+public:
+  WifiMeshMultihopActionHeader ();
+  ~WifiMeshMultihopActionHeader ();
+  enum CategoryValue //table 7-24 staring from 4
+  {
+    MESH_PEER_LINK_MGT =4,
+    MESH_LINK_METRIC,
+    MESH_PATH_SELECTION,
+    MESH_INTERWORK_ACTION,
+    MESH_RESOURCE_COORDINATION,
+  };
+  enum PeerLinkMgtActionValue
+  {
+    PEER_LINK_OPEN = 0,
+    PEER_LINK_CONFIRM,
+    PEER_LINK_CLOSE,
+  };
+  enum LinkMetricActionValue
+  {
+    LINK_METRIC_REQUEST = 0,
+    LINK_METRIC_REPORT,
+  };
+  enum PathSelectionActionValue
+  {
+    PATH_REQUEST = 0,
+    PATH_REPLY,
+    PATH_ERROR,
+    ROOT_ANNOUNCEMENT,
+  };
+  enum InterworkActionValue
+  {
+    PORTAL_ANNOUNCEMENT = 0,
+  };
+  enum ResourceCoordinationActionValue
+  {
+    CONGESTION_CONTROL_NOTIFICATION = 0,
+    MDA_SETUP_REQUEST,
+    MDA_SETUP_REPLY,
+    MDAOP_ADVERTISMENT_REQUEST,
+    MDAOP_ADVERTISMENTS,
+    MDAOP_SET_TEARDOWN,
+    BEACON_TIMING_REQUEST,
+    BEACON_TIMING_RESPONSE,
+    TBTT_ADJASTMENT_REQUEST,
+    MESH_CHANNEL_SWITCH_ANNOUNCEMENT,
+  };
+  typedef union
+  {
+    enum PeerLinkMgtActionValue  peerLink;
+    enum LinkMetricActionValue  linkMetrtic;
+    enum PathSelectionActionValue  pathSelection;
+    enum InterworkActionValue  interwork;
+    enum ResourceCoordinationActionValue resourceCoordination;
+  } ACTION_VALUE;
+  void   SetAction(enum CategoryValue type,ACTION_VALUE action);
+  enum CategoryValue GetCategory();
+  ACTION_VALUE  GetAction();
+  static TypeId  GetTypeId ();
+  virtual TypeId  GetInstanceTypeId () const;
+  virtual void  Print (std::ostream &os) const;
+  virtual uint32_t GetSerializedSize () const;
+  virtual void  Serialize (Buffer::Iterator start) const;
+  virtual uint32_t Deserialize (Buffer::Iterator start);
+private:
+  uint8_t m_category;
+  uint8_t m_actionValue;
 };
 } // namespace ns3
 #endif /* MESH_WIFI_MAC_HEADER_H */
diff --git a/src/devices/wifi/mesh-wifi-mac.cc b/src/devices/wifi/mesh-wifi-mac.cc
index 4ef61f41b..b0e08be4c 100644
--- a/src/devices/wifi/mesh-wifi-mac.cc
+++ b/src/devices/wifi/mesh-wifi-mac.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -46,171 +46,171 @@ NS_OBJECT_ENSURE_REGISTERED (MeshWifiMac);
 TypeId
 MeshWifiMac::GetTypeId ()
 {
-	static TypeId tid = TypeId ("ns3::MeshWifiMac")
-		.SetParent<WifiMac> ()
-		.AddConstructor<MeshWifiMac> ()
-		.AddAttribute ("BeaconInterval", "Beacon Interval",
-				TimeValue (Seconds (1.0)),
-				MakeTimeAccessor (&MeshWifiMac::m_beaconInterval),
-				MakeTimeChecker ()
-				)
-		.AddAttribute ("RandomStart", "Window when beacon generating starts (uniform random) in seconds",
-				TimeValue (Seconds (0.1)),
-				MakeTimeAccessor (&MeshWifiMac::m_randomStart),
-				MakeTimeChecker ()
-				)
-		.AddAttribute ("SoftwareDelay", "Window of uniformely distributed random software handling delay",
-				TimeValue (MicroSeconds (500)),
-				MakeTimeAccessor (&MeshWifiMac::m_softwareDelay),
-				MakeTimeChecker ()
-				)
-		.AddAttribute ("BeaconGeneration", "Enable/Disable Beaconing.",
-				BooleanValue (true),
-				MakeBooleanAccessor (
-					&MeshWifiMac::SetBeaconGeneration,
-					&MeshWifiMac::GetBeaconGeneration
-					),
-					MakeBooleanChecker ()
-				);
-	return tid;
+  static TypeId tid = TypeId ("ns3::MeshWifiMac")
+                      .SetParent<WifiMac> ()
+                      .AddConstructor<MeshWifiMac> ()
+                      .AddAttribute ("BeaconInterval", "Beacon Interval",
+                                     TimeValue (Seconds (1.0)),
+                                     MakeTimeAccessor (&MeshWifiMac::m_beaconInterval),
+                                     MakeTimeChecker ()
+                                    )
+                      .AddAttribute ("RandomStart", "Window when beacon generating starts (uniform random) in seconds",
+                                     TimeValue (Seconds (0.1)),
+                                     MakeTimeAccessor (&MeshWifiMac::m_randomStart),
+                                     MakeTimeChecker ()
+                                    )
+                      .AddAttribute ("SoftwareDelay", "Window of uniformely distributed random software handling delay",
+                                     TimeValue (MicroSeconds (500)),
+                                     MakeTimeAccessor (&MeshWifiMac::m_softwareDelay),
+                                     MakeTimeChecker ()
+                                    )
+                      .AddAttribute ("BeaconGeneration", "Enable/Disable Beaconing.",
+                                     BooleanValue (true),
+                                     MakeBooleanAccessor (
+                                       &MeshWifiMac::SetBeaconGeneration,
+                                       &MeshWifiMac::GetBeaconGeneration
+                                     ),
+                                     MakeBooleanChecker ()
+                                    );
+  return tid;
 }
 
 MeshWifiMac::MeshWifiMac ()
 {
-	NS_LOG_FUNCTION (this);
-	m_rxMiddle = new MacRxMiddle ();
-	m_rxMiddle->SetForwardCallback (MakeCallback (&MeshWifiMac::Receive, this));
+  NS_LOG_FUNCTION (this);
+  m_rxMiddle = new MacRxMiddle ();
+  m_rxMiddle->SetForwardCallback (MakeCallback (&MeshWifiMac::Receive, this));
 
-	m_low = CreateObject<MacLow> ();
-	m_low->SetRxCallback (MakeCallback (&MacRxMiddle::Receive, m_rxMiddle));
+  m_low = CreateObject<MacLow> ();
+  m_low->SetRxCallback (MakeCallback (&MacRxMiddle::Receive, m_rxMiddle));
 
-	m_dcfManager = new DcfManager ();
-	m_dcfManager->SetupLowListener (m_low);
+  m_dcfManager = new DcfManager ();
+  m_dcfManager->SetupLowListener (m_low);
 
-	m_beaconDca = CreateObject<DcaTxop> ();
-	m_beaconDca->SetLow (m_low);
-	m_beaconDca->SetMinCw (0);
-	m_beaconDca->SetMaxCw (0);
-	m_beaconDca->SetAifsn(1);
-	m_beaconDca->SetManager (m_dcfManager);
+  m_beaconDca = CreateObject<DcaTxop> ();
+  m_beaconDca->SetLow (m_low);
+  m_beaconDca->SetMinCw (0);
+  m_beaconDca->SetMaxCw (0);
+  m_beaconDca->SetAifsn(1);
+  m_beaconDca->SetManager (m_dcfManager);
 
-	m_VO = CreateObject<DcaTxop> ();
-	m_VO->SetLow (m_low);
-	m_VO->SetMinCw (3);
-	m_VO->SetMaxCw (7);
-	m_VO->SetManager (m_dcfManager);
-	m_VO->SetTxOkCallback (MakeCallback (&MeshWifiMac::TxOk, this));
-	m_VO->SetTxFailedCallback (MakeCallback (&MeshWifiMac::TxFailed, this));
+  m_VO = CreateObject<DcaTxop> ();
+  m_VO->SetLow (m_low);
+  m_VO->SetMinCw (3);
+  m_VO->SetMaxCw (7);
+  m_VO->SetManager (m_dcfManager);
+  m_VO->SetTxOkCallback (MakeCallback (&MeshWifiMac::TxOk, this));
+  m_VO->SetTxFailedCallback (MakeCallback (&MeshWifiMac::TxFailed, this));
 
-	m_BE = CreateObject<DcaTxop> ();
-	m_BE->SetLow (m_low);
-	m_BE->SetManager (m_dcfManager);
-	m_BE->SetTxOkCallback (MakeCallback (&MeshWifiMac::TxOk, this));
-	m_BE->SetTxFailedCallback (MakeCallback (&MeshWifiMac::TxFailed, this));
+  m_BE = CreateObject<DcaTxop> ();
+  m_BE->SetLow (m_low);
+  m_BE->SetManager (m_dcfManager);
+  m_BE->SetTxOkCallback (MakeCallback (&MeshWifiMac::TxOk, this));
+  m_BE->SetTxFailedCallback (MakeCallback (&MeshWifiMac::TxFailed, this));
 }
 
 MeshWifiMac::~MeshWifiMac ()
 {
-	NS_LOG_FUNCTION (this);
+  NS_LOG_FUNCTION (this);
 }
 /*
  * Public Methods:
  */
-void 
+void
 MeshWifiMac::SetSlot (Time slotTime)
 {
-	NS_LOG_FUNCTION (this << slotTime);
-	m_dcfManager->SetSlot (slotTime);
-	m_slot = slotTime;
+  NS_LOG_FUNCTION (this << slotTime);
+  m_dcfManager->SetSlot (slotTime);
+  m_slot = slotTime;
 }
 
-void 
-MeshWifiMac::SetSifs (Time sifs) 
+void
+MeshWifiMac::SetSifs (Time sifs)
 {
-	NS_LOG_FUNCTION (this << sifs); 
-	m_dcfManager->SetSifs (sifs);
-	m_sifs = sifs;
+  NS_LOG_FUNCTION (this << sifs);
+  m_dcfManager->SetSifs (sifs);
+  m_sifs = sifs;
 }
-void 
+void
 MeshWifiMac::SetAckTimeout (Time ackTimeout)
 {
-	m_low->SetAckTimeout (ackTimeout);
+  m_low->SetAckTimeout (ackTimeout);
 }
 
-void 
+void
 MeshWifiMac::SetCtsTimeout (Time ctsTimeout)
 {
-	m_low->SetCtsTimeout (ctsTimeout);
+  m_low->SetCtsTimeout (ctsTimeout);
 }
 
-void 
-MeshWifiMac::SetPifs (Time pifs) 
+void
+MeshWifiMac::SetPifs (Time pifs)
 {
-	NS_LOG_FUNCTION (this << pifs); 
-	m_pifs = pifs;
+  NS_LOG_FUNCTION (this << pifs);
+  m_pifs = pifs;
 }
 void
 MeshWifiMac::SetEifsNoDifs (Time eifsNoDifs)
 {
-	NS_LOG_FUNCTION (this << eifsNoDifs);
-	m_dcfManager->SetEifsNoDifs (eifsNoDifs);
-	m_eifsNoDifs = eifsNoDifs;
+  NS_LOG_FUNCTION (this << eifsNoDifs);
+  m_dcfManager->SetEifsNoDifs (eifsNoDifs);
+  m_eifsNoDifs = eifsNoDifs;
 }
 
-Time 
+Time
 MeshWifiMac::GetSlot () const
-{
-	return m_slot;
-}
+  {
+    return m_slot;
+  }
 
-Time 
+Time
 MeshWifiMac::GetSifs () const
-{
-	return m_sifs;
-}
+  {
+    return m_sifs;
+  }
 
-Time 
+Time
 MeshWifiMac::GetEifsNoDifs () const
-{
-	return m_eifsNoDifs;
-}
+  {
+    return m_eifsNoDifs;
+  }
 
-Time 
+Time
 MeshWifiMac::GetAckTimeout () const
-{
-	return m_low->GetAckTimeout ();
-}
+  {
+    return m_low->GetAckTimeout ();
+  }
 
-Time 
+Time
 MeshWifiMac::GetCtsTimeout () const
-{
-	return m_low->GetCtsTimeout ();
-}
+  {
+    return m_low->GetCtsTimeout ();
+  }
 
-Time 
+Time
 MeshWifiMac::GetPifs () const
-{
-	return m_low->GetPifs ();
-}
+  {
+    return m_low->GetPifs ();
+  }
 
 void
 MeshWifiMac::SetWifiPhy (Ptr<WifiPhy> phy)
 {
-	NS_LOG_FUNCTION (this << phy);
-	m_phy = phy;
-	m_dcfManager->SetupPhyListener (phy);
-	m_low->SetPhy (phy);
+  NS_LOG_FUNCTION (this << phy);
+  m_phy = phy;
+  m_dcfManager->SetupPhyListener (phy);
+  m_low->SetPhy (phy);
 }
 
-void 
+void
 MeshWifiMac::SetWifiRemoteStationManager (Ptr<WifiRemoteStationManager> stationManager)
 {
-	NS_LOG_FUNCTION (this << stationManager);
-	m_stationManager = stationManager;
-	m_BE->SetWifiRemoteStationManager (stationManager);
-	m_VO->SetWifiRemoteStationManager (stationManager);
-	m_beaconDca->SetWifiRemoteStationManager (stationManager);
-	m_low->SetWifiRemoteStationManager (stationManager);
+  NS_LOG_FUNCTION (this << stationManager);
+  m_stationManager = stationManager;
+  m_BE->SetWifiRemoteStationManager (stationManager);
+  m_VO->SetWifiRemoteStationManager (stationManager);
+  m_beaconDca->SetWifiRemoteStationManager (stationManager);
+  m_low->SetWifiRemoteStationManager (stationManager);
 }
 
 void
@@ -219,255 +219,255 @@ MeshWifiMac::SetPeerLinkManager (Ptr<WifiPeerManager> manager)
   m_peerManager = manager;
 }
 
-void 
+void
 MeshWifiMac::Enqueue (Ptr<const Packet> packet, Mac48Address to, Mac48Address from)
 {
-	NS_LOG_FUNCTION (this << packet << to << from);
-	ForwardDown (packet, from, to);
+  NS_LOG_FUNCTION (this << packet << to << from);
+  ForwardDown (packet, from, to);
 }
 
-void 
+void
 MeshWifiMac::Enqueue (Ptr<const Packet> packet, Mac48Address to)
 {
-	NS_LOG_FUNCTION (this << packet << to);
-	ForwardDown (packet, m_low->GetAddress (), to);
+  NS_LOG_FUNCTION (this << packet << to);
+  ForwardDown (packet, m_low->GetAddress (), to);
 }
 
-bool 
+bool
 MeshWifiMac::SupportsSendFrom () const
-{
-	return true;
-}
+  {
+    return true;
+  }
 
-void 
+void
 MeshWifiMac::SetForwardUpCallback (Callback<void,Ptr<Packet>, Mac48Address, Mac48Address> upCallback)
 {
-	NS_LOG_FUNCTION (this);
-	m_upCallback = upCallback;
+  NS_LOG_FUNCTION (this);
+  m_upCallback = upCallback;
 }
 
-void 
+void
 MeshWifiMac::SetLinkUpCallback (Callback<void> linkUp)
 {
-	NS_LOG_FUNCTION (this);
-	if (!linkUp.IsNull ())
-	{
-		linkUp ();
-	}
+  NS_LOG_FUNCTION (this);
+  if (!linkUp.IsNull ())
+    {
+      linkUp ();
+    }
 }
 
-void 
+void
 MeshWifiMac::SetLinkDownCallback (Callback<void> linkDown)
 {
-	NS_LOG_FUNCTION (this);
+  NS_LOG_FUNCTION (this);
 }
 
-Mac48Address 
+Mac48Address
 MeshWifiMac::GetAddress () const
-{
-	return m_address;
-}
+  {
+    return m_address;
+  }
 Mac48Address
 MeshWifiMac::GetBssid () const
-{
-	return m_address;
-}
+  {
+    return m_address;
+  }
 
-Ssid 
+Ssid
 MeshWifiMac::GetSsid () const
-{
-	return m_MeshId;
-}
+  {
+    return m_MeshId;
+  }
 
-void 
+void
 MeshWifiMac::SetAddress (Mac48Address address)
 {
-	NS_LOG_FUNCTION (address);
-	m_low->SetAddress(address);
-	m_address = address;
+  NS_LOG_FUNCTION (address);
+  m_low->SetAddress(address);
+  m_address = address;
 }
 
-void 
+void
 MeshWifiMac::SetSsid (Ssid ssid)
 {
-	NS_LOG_FUNCTION (ssid);
-	m_MeshId = ssid;
+  NS_LOG_FUNCTION (ssid);
+  m_MeshId = ssid;
 }
 
-void 
+void
 MeshWifiMac::SetBeaconInterval (Time interval)
 {
-	NS_LOG_FUNCTION (this << interval);
-	m_beaconInterval = interval;
+  NS_LOG_FUNCTION (this << interval);
+  m_beaconInterval = interval;
 }
 
 void
 MeshWifiMac::DoDispose ()
 {
-	NS_LOG_FUNCTION (this);
-	delete m_rxMiddle;
-	delete m_dcfManager;
-	//Delete smart pointers:
-	m_rxMiddle = 0;
-	m_low = 0;
-	m_dcfManager = 0;
-	m_phy = 0;
-	m_BE = 0;
-	m_VO = 0;
-	m_peerManager = 0;
-	m_beaconSendEvent.Cancel ();
-	m_beaconFormEvent.Cancel ();
-	m_beaconDca = 0;
-	WifiMac::DoDispose ();
+  NS_LOG_FUNCTION (this);
+  delete m_rxMiddle;
+  delete m_dcfManager;
+  //Delete smart pointers:
+  m_rxMiddle = 0;
+  m_low = 0;
+  m_dcfManager = 0;
+  m_phy = 0;
+  m_BE = 0;
+  m_VO = 0;
+  m_peerManager = 0;
+  m_beaconSendEvent.Cancel ();
+  m_beaconFormEvent.Cancel ();
+  m_beaconDca = 0;
+  WifiMac::DoDispose ();
 }
 
-void 
+void
 MeshWifiMac::ForwardUp (Ptr<Packet> packet, Mac48Address src, Mac48Address dst)
 {
-	NS_LOG_FUNCTION (this << packet << src);
-	m_upCallback (packet, src, dst);
+  NS_LOG_FUNCTION (this << packet << src);
+  m_upCallback (packet, src, dst);
 }
 
-void 
+void
 MeshWifiMac::ForwardDown (Ptr<const Packet> packet, Mac48Address from, Mac48Address to)
 {
-	//TODO:Classify and queue
-	WifiMacHeader hdr;
-	Ptr<Packet> packet_to_send = packet->Copy();
-	WifiMeshHeader meshHdr;
-	//Address 1 we receive from HWMP tag
-	HwmpTag tag;
-	NS_ASSERT(packet->FindFirstMatchingTag(tag));
-	meshHdr.SetMeshTtl(tag.GetTtl());
-	meshHdr.SetMeshSeqno(tag.GetSeqno());
+  //TODO:Classify and queue
+  WifiMacHeader hdr;
+  Ptr<Packet> packet_to_send = packet->Copy();
+  WifiMeshHeader meshHdr;
+  //Address 1 we receive from HWMP tag
+  HwmpTag tag;
+  NS_ASSERT(packet->FindFirstMatchingTag(tag));
+  meshHdr.SetMeshTtl(tag.GetTtl());
+  meshHdr.SetMeshSeqno(tag.GetSeqno());
 #if 0
-	NS_LOG_DEBUG(
-			"TX Packet sa = "<<from<<
-			", da = "<<to<<
-			", ra = "<<tag.GetAddress()<<
-			", I am "<<GetAddress()<<
-			", ttl = "<<(int)meshHdr.GetMeshTtl()
-			);
+  NS_LOG_DEBUG(
+    "TX Packet sa = "<<from<<
+    ", da = "<<to<<
+    ", ra = "<<tag.GetAddress()<<
+    ", I am "<<GetAddress()<<
+    ", ttl = "<<(int)meshHdr.GetMeshTtl()
+  );
 #endif
-	if(to!= Mac48Address::GetBroadcast())
-		NS_ASSERT(tag.GetAddress()!=Mac48Address::GetBroadcast());
-	hdr.SetTypeData ();
-	hdr.SetAddr1 (tag.GetAddress());
-	hdr.SetAddr2 (GetAddress ());
-	hdr.SetAddr3 (to);
-	hdr.SetAddr4(from);
-	hdr.SetDsFrom ();
-	hdr.SetDsTo ();
-	//TODO: classify should be fixed!
-	packet_to_send->AddHeader(meshHdr);
-	WifiRemoteStation *destination = m_stationManager->Lookup (to);
-  
-	if (destination->IsBrandNew ())
-	{
-		// in adhoc mode, we assume that every destination
-		// supports all the rates we support.
-		for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
-		{
-			destination->AddSupportedMode (m_phy->GetMode (i));
-		}
-		destination->RecordDisassociated ();
-	}
-	m_BE->Queue (packet_to_send, hdr);
+  if (to!= Mac48Address::GetBroadcast())
+    NS_ASSERT(tag.GetAddress()!=Mac48Address::GetBroadcast());
+  hdr.SetTypeData ();
+  hdr.SetAddr1 (tag.GetAddress());
+  hdr.SetAddr2 (GetAddress ());
+  hdr.SetAddr3 (to);
+  hdr.SetAddr4(from);
+  hdr.SetDsFrom ();
+  hdr.SetDsTo ();
+  //TODO: classify should be fixed!
+  packet_to_send->AddHeader(meshHdr);
+  WifiRemoteStation *destination = m_stationManager->Lookup (to);
+
+  if (destination->IsBrandNew ())
+    {
+      // in adhoc mode, we assume that every destination
+      // supports all the rates we support.
+      for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
+        {
+          destination->AddSupportedMode (m_phy->GetMode (i));
+        }
+      destination->RecordDisassociated ();
+    }
+  m_BE->Queue (packet_to_send, hdr);
 }
 
 SupportedRates
 MeshWifiMac::GetSupportedRates () const
-{
-	// send the set of supported rates and make sure that we indicate
-	// the Basic Rate set in this set of supported rates.
-	SupportedRates rates;
-	for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
-	{
-		WifiMode mode = m_phy->GetMode (i);
-		rates.AddSupportedRate (mode.GetDataRate ());
-	}
-	// set the basic rates
-	for (uint32_t j = 0; j < m_stationManager->GetNBasicModes (); j++)
-	{
-		WifiMode mode = m_stationManager->GetBasicMode (j);
-		rates.SetBasicRate (mode.GetDataRate ());
-	}
-	return rates;
-}
+  {
+    // send the set of supported rates and make sure that we indicate
+    // the Basic Rate set in this set of supported rates.
+    SupportedRates rates;
+    for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
+      {
+        WifiMode mode = m_phy->GetMode (i);
+        rates.AddSupportedRate (mode.GetDataRate ());
+      }
+    // set the basic rates
+    for (uint32_t j = 0; j < m_stationManager->GetNBasicModes (); j++)
+      {
+        WifiMode mode = m_stationManager->GetBasicMode (j);
+        rates.SetBasicRate (mode.GetDataRate ());
+      }
+    return rates;
+  }
 
 void
 MeshWifiMac::SendOneBeacon ()
 {
-	NS_LOG_FUNCTION (this);
-	NS_LOG_DEBUG(GetAddress()<<" is sending beacon");
-	//Software delay should never be bigger than beacon interval!
-	NS_ASSERT(!m_beaconSendEvent.IsRunning());
-	Time last_software_delay = m_beaconFormingRandomDelay;
-	MgtMeshBeaconHeader beacon;
-	beacon.SetSsid (GetSsid ());
-	beacon.SetSupportedRates (GetSupportedRates ());
-	beacon.SetBeaconIntervalUs (m_beaconInterval.GetMicroSeconds ());
-	beacon.SetWifiBeaconTimingElement(m_peerManager->GetWifiBeaconTimingElementForMyBeacon(GetAddress()));
-	m_beaconSendEvent = Simulator::Schedule(
-			m_beaconFormingRandomDelay,
-			&MeshWifiMac::QueueOneBeacon,
-			this,
-			beacon);
-	UniformVariable coefficient(0.0, m_beaconFormingRandomDelay.GetSeconds());
-	m_beaconFormingRandomDelay = Seconds(coefficient.GetValue());
+  NS_LOG_FUNCTION (this);
+  NS_LOG_DEBUG(GetAddress()<<" is sending beacon");
+  //Software delay should never be bigger than beacon interval!
+  NS_ASSERT(!m_beaconSendEvent.IsRunning());
+  Time last_software_delay = m_beaconFormingRandomDelay;
+  MgtMeshBeaconHeader beacon;
+  beacon.SetSsid (GetSsid ());
+  beacon.SetSupportedRates (GetSupportedRates ());
+  beacon.SetBeaconIntervalUs (m_beaconInterval.GetMicroSeconds ());
+  beacon.SetWifiBeaconTimingElement(m_peerManager->GetWifiBeaconTimingElementForMyBeacon(GetAddress()));
+  m_beaconSendEvent = Simulator::Schedule(
+                        m_beaconFormingRandomDelay,
+                        &MeshWifiMac::QueueOneBeacon,
+                        this,
+                        beacon);
+  UniformVariable coefficient(0.0, m_beaconFormingRandomDelay.GetSeconds());
+  m_beaconFormingRandomDelay = Seconds(coefficient.GetValue());
 
-        //MBCA functionality, TODO: add the switch off/on MBCA mechanism capability
-        //Let's find when we send the next beacon
-        Time myNextTBTT = Simulator::Now ()+m_beaconInterval+last_software_delay;
-        //The mext function compares my TBTT with neighbor's TBTTs using timing elemnt
-        //and returns time shift for the next beacon if future collision is detected
- 	Time nextBeaconShift = m_peerManager->GetNextBeaconShift(GetAddress(), myNextTBTT);
+  //MBCA functionality, TODO: add the switch off/on MBCA mechanism capability
+  //Let's find when we send the next beacon
+  Time myNextTBTT = Simulator::Now ()+m_beaconInterval+last_software_delay;
+  //The mext function compares my TBTT with neighbor's TBTTs using timing elemnt
+  //and returns time shift for the next beacon if future collision is detected
+  Time nextBeaconShift = m_peerManager->GetNextBeaconShift(GetAddress(), myNextTBTT);
 
-	m_beaconFormEvent = Simulator::Schedule (m_beaconInterval-m_beaconFormingRandomDelay+last_software_delay+nextBeaconShift, &MeshWifiMac::SendOneBeacon, this);
+  m_beaconFormEvent = Simulator::Schedule (m_beaconInterval-m_beaconFormingRandomDelay+last_software_delay+nextBeaconShift, &MeshWifiMac::SendOneBeacon, this);
 }
 
 void
 MeshWifiMac::QueueOneBeacon (MgtMeshBeaconHeader beacon_hdr)
 {
-	WifiMacHeader hdr;
-	hdr.SetBeacon ();
-	hdr.SetAddr1 (Mac48Address::GetBroadcast ());
-	hdr.SetAddr2 (GetAddress ());
-	hdr.SetAddr3 (GetAddress ());
-	hdr.SetDsNotFrom ();
-	hdr.SetDsNotTo ();
-	Ptr<Packet> packet = Create<Packet> ();
+  WifiMacHeader hdr;
+  hdr.SetBeacon ();
+  hdr.SetAddr1 (Mac48Address::GetBroadcast ());
+  hdr.SetAddr2 (GetAddress ());
+  hdr.SetAddr3 (GetAddress ());
+  hdr.SetDsNotFrom ();
+  hdr.SetDsNotTo ();
+  Ptr<Packet> packet = Create<Packet> ();
 
-	packet->AddHeader (beacon_hdr);
-	m_beaconDca->Queue(packet, hdr);
-	m_peerManager->SetSentBeaconTimers(
-			GetAddress(),
-			Simulator::Now (),
-			MicroSeconds(beacon_hdr.GetBeaconIntervalUs())
-			);
+  packet->AddHeader (beacon_hdr);
+  m_beaconDca->Queue(packet, hdr);
+  m_peerManager->SetSentBeaconTimers(
+    GetAddress(),
+    Simulator::Now (),
+    MicroSeconds(beacon_hdr.GetBeaconIntervalUs())
+  );
 
 }
 void
 MeshWifiMac::SetBeaconGeneration (bool enable)
 {
-	NS_LOG_FUNCTION (this << enable);
-	if (enable)
-	{
-		UniformVariable coefficient(0.0, m_randomStart.GetSeconds());
-		Time randomStart = Seconds(coefficient.GetValue());
-		// Beacons must be sent with a random delay,
-		// otherwise, they will all be broken
-		m_beaconFormEvent = Simulator::Schedule (randomStart, &MeshWifiMac::SendOneBeacon, this);
-	}
-	else
-		m_beaconFormEvent.Cancel ();
+  NS_LOG_FUNCTION (this << enable);
+  if (enable)
+    {
+      UniformVariable coefficient(0.0, m_randomStart.GetSeconds());
+      Time randomStart = Seconds(coefficient.GetValue());
+      // Beacons must be sent with a random delay,
+      // otherwise, they will all be broken
+      m_beaconFormEvent = Simulator::Schedule (randomStart, &MeshWifiMac::SendOneBeacon, this);
+    }
+  else
+    m_beaconFormEvent.Cancel ();
 }
 
 bool
 MeshWifiMac::GetBeaconGeneration () const
-{
-	return m_beaconFormEvent.IsRunning ();
-}
+  {
+    return m_beaconFormEvent.IsRunning ();
+  }
 
 void
 MeshWifiMac::TxOk (WifiMacHeader const &hdr)
@@ -479,481 +479,481 @@ MeshWifiMac::TxFailed (WifiMacHeader const &hdr)
 {
 }
 
-void 
+void
 MeshWifiMac::Receive (Ptr<Packet> packet, WifiMacHeader const *hdr)
 {
-	if (hdr->IsBeacon ()) 
-	{
-		MgtMeshBeaconHeader beacon;
-		Mac48Address from = hdr->GetAddr2();
-		packet->RemoveHeader (beacon);
-		NS_LOG_DEBUG("Beacon received from "<<hdr->GetAddr2()<<
-				" to "<<GetAddress()<<
-				" at "<<Simulator::Now ().GetMicroSeconds ()<<
-				" microseconds");
+  if (hdr->IsBeacon ())
+    {
+      MgtMeshBeaconHeader beacon;
+      Mac48Address from = hdr->GetAddr2();
+      packet->RemoveHeader (beacon);
+      NS_LOG_DEBUG("Beacon received from "<<hdr->GetAddr2()<<
+                   " to "<<GetAddress()<<
+                   " at "<<Simulator::Now ().GetMicroSeconds ()<<
+                   " microseconds");
 #if 0
-		NeighboursTimingUnitsList neighbours;
-		neighbours = beacon.GetWifiBeaconTimingElement().GetNeighboursTimingElementsList();
-		for(NeighboursTimingUnitsList::const_iterator j = neighbours.begin(); j!= neighbours.end(); j++)
-			fprintf(
-					stderr,
-					"neigbours:\nAID=%u, last_beacon=%u ,beacon_interval=%u\n",
-					(*j)->GetAID(),
-					(*j)->GetLastBeacon(),
-					(*j)->GetBeaconInterval()
-					);
+      NeighboursTimingUnitsList neighbours;
+      neighbours = beacon.GetWifiBeaconTimingElement().GetNeighboursTimingElementsList();
+      for (NeighboursTimingUnitsList::const_iterator j = neighbours.begin(); j!= neighbours.end(); j++)
+        fprintf(
+          stderr,
+          "neigbours:\nAID=%u, last_beacon=%u ,beacon_interval=%u\n",
+          (*j)->GetAID(),
+          (*j)->GetLastBeacon(),
+          (*j)->GetBeaconInterval()
+        );
 #endif
-		m_peerManager->SetReceivedBeaconTimers(
-				GetAddress(),
-				from,
-				Simulator::Now (),
-				MicroSeconds(beacon.GetBeaconIntervalUs()),
-				beacon.GetWifiBeaconTimingElement()
-				);
-		if(!beacon.GetSsid().IsEqual(GetSsid()))
-			return;
-		SupportedRates rates = beacon.GetSupportedRates ();
-		WifiRemoteStation *peerSta = m_stationManager->Lookup (hdr->GetAddr2 ());
-		for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
-		{
-			WifiMode mode = m_phy->GetMode (i);
-			if (rates.IsSupportedRate (mode.GetDataRate ()))
-			{
-				peerSta->AddSupportedMode (mode);
-				if (rates.IsBasicRate (mode.GetDataRate ()))
-				{
-					m_stationManager->AddBasicMode (mode);
-				}
-			}
-		}
-		// TODO:Chack MeshConfigurationElement(now is nothing
-		// to be checked)
-		m_peerManager->AskIfOpenNeeded(GetAddress(), from);
-		return;
-	}
-	if(hdr->IsMultihopAction())
-	{
-		WifiMeshHeader meshHdr;
-		//no mesh header parameters are needed here:
-		//TODO: check TTL
-		packet->RemoveHeader(meshHdr);
-		WifiMeshMultihopActionHeader multihopHdr;
-		//parse multihop action header:
-		packet->RemoveHeader(multihopHdr);
-		WifiMeshMultihopActionHeader::ACTION_VALUE
-			actionValue = multihopHdr.GetAction();
-		switch(multihopHdr.GetCategory())
-		{
-			case WifiMeshMultihopActionHeader::MESH_PEER_LINK_MGT:
-			{
-				Mac48Address peerAddress; 
-				MeshMgtPeerLinkManFrame peer_frame;
-				if(hdr->GetAddr1 () != GetAddress ())
-					return;
-				peerAddress = hdr->GetAddr2();
-				packet->RemoveHeader (peer_frame);
-				if(actionValue.peerLink != WifiMeshMultihopActionHeader::PEER_LINK_CLOSE)
-				{
-					//check Supported Rates
-					SupportedRates rates = peer_frame.GetSupportedRates();
-					for (uint32_t i = 0; i < m_stationManager->GetNBasicModes (); i++)
-					{
-						WifiMode mode = m_stationManager->GetBasicMode (i);
-						if (!rates.IsSupportedRate (mode.GetDataRate ()))
-						{
-							m_peerManager->ConfigurationMismatch(GetAddress(), peerAddress);
-							return;
-						}
-					}
-					//Check SSID
-					if(!peer_frame.GetMeshId().IsEqual(GetSsid()))
-					{
-						m_peerManager->ConfigurationMismatch(GetAddress(), peerAddress);
-						return;
-					}
-				}
-				switch(actionValue.peerLink)
-				{
-					case WifiMeshMultihopActionHeader::PEER_LINK_CONFIRM:
-						m_peerManager->SetConfirmReceived(
-								GetAddress(),
-								peerAddress,
-								peer_frame.GetAid(),
-								peer_frame.GetPeerLinkManagementElement(),
-								m_meshConfig
-								);
-						return;
-					case WifiMeshMultihopActionHeader::PEER_LINK_OPEN:
-						m_peerManager->SetOpenReceived(
-								GetAddress(),
-								peerAddress,
-								peer_frame.GetPeerLinkManagementElement(),
-								m_meshConfig
-								);
-						return;
-					case WifiMeshMultihopActionHeader::PEER_LINK_CLOSE:
-						m_peerManager->SetCloseReceived(
-								GetAddress(),
-								peerAddress,
-								peer_frame.GetPeerLinkManagementElement()
-								);
-						return;
-					default:
-						return;
-			}
-				break;
-				}
-			case WifiMeshMultihopActionHeader::MESH_PATH_SELECTION:
-			{
-				if(!m_peerManager->IsActiveLink(GetAddress(), hdr->GetAddr2()))
-					return;
-				switch(actionValue.pathSelection)
-				{
-					case WifiMeshMultihopActionHeader::PATH_REQUEST:
-						{
-						WifiPreqInformationElement preq;
-						packet->RemoveHeader(preq);
-						//TODO:recalculate
-						//metric
-						m_preqReceived(preq, hdr->GetAddr2(), CalculateMetric(hdr->GetAddr2()));
-						return;
-						}
-					case WifiMeshMultihopActionHeader::PATH_REPLY:
-						{
-						WifiPrepInformationElement prep;
-						packet->RemoveHeader(prep);
-						m_prepReceived(prep, hdr->GetAddr2(), CalculateMetric(hdr->GetAddr2()));
-						}
-						return;
-					case WifiMeshMultihopActionHeader::PATH_ERROR:
-						{
-						WifiPerrInformationElement perr;
-						packet->RemoveHeader(perr);
-						m_perrReceived(perr, hdr->GetAddr2());
-						}
-						return;
-					case WifiMeshMultihopActionHeader::ROOT_ANNOUNCEMENT:
-						return;
-				}
-			}
-			default:
-				break;
-		}
-	}
-	if(hdr->IsData())
-	{
-		NS_ASSERT((hdr->IsFromDs()) && (hdr->IsToDs()));
-		NS_ASSERT(hdr->GetAddr4()!=Mac48Address::GetBroadcast());
-		//check seqno
-		WifiMeshHeader meshHdr;
-		packet->RemoveHeader(meshHdr);
-		NS_LOG_DEBUG(
-				"DATA TA="<< hdr->GetAddr2()<<
-				", da="<<hdr->GetAddr3()<<
-				", sa="<<hdr->GetAddr4()<<
-				", TTL="<<(int)meshHdr.GetMeshTtl());
-		HwmpTag tag;
-		//mesh header is present within DATA and multihop action frames, so it must be done within MAC
-		tag.SetSeqno(meshHdr.GetMeshSeqno());
-		tag.SetAddress(hdr->GetAddr2());
-		tag.SetTtl(meshHdr.GetMeshTtl());
-		//metric should be later
-		packet->RemoveAllTags();
-		packet->AddTag(tag);
-	if(m_peerManager->IsActiveLink(GetAddress(), hdr->GetAddr2()))
-		ForwardUp(packet, hdr->GetAddr4(), hdr->GetAddr3());
-	}
+      m_peerManager->SetReceivedBeaconTimers(
+        GetAddress(),
+        from,
+        Simulator::Now (),
+        MicroSeconds(beacon.GetBeaconIntervalUs()),
+        beacon.GetWifiBeaconTimingElement()
+      );
+      if (!beacon.GetSsid().IsEqual(GetSsid()))
+        return;
+      SupportedRates rates = beacon.GetSupportedRates ();
+      WifiRemoteStation *peerSta = m_stationManager->Lookup (hdr->GetAddr2 ());
+      for (uint32_t i = 0; i < m_phy->GetNModes (); i++)
+        {
+          WifiMode mode = m_phy->GetMode (i);
+          if (rates.IsSupportedRate (mode.GetDataRate ()))
+            {
+              peerSta->AddSupportedMode (mode);
+              if (rates.IsBasicRate (mode.GetDataRate ()))
+                {
+                  m_stationManager->AddBasicMode (mode);
+                }
+            }
+        }
+      // TODO:Chack MeshConfigurationElement(now is nothing
+      // to be checked)
+      m_peerManager->AskIfOpenNeeded(GetAddress(), from);
+      return;
+    }
+  if (hdr->IsMultihopAction())
+    {
+      WifiMeshHeader meshHdr;
+      //no mesh header parameters are needed here:
+      //TODO: check TTL
+      packet->RemoveHeader(meshHdr);
+      WifiMeshMultihopActionHeader multihopHdr;
+      //parse multihop action header:
+      packet->RemoveHeader(multihopHdr);
+      WifiMeshMultihopActionHeader::ACTION_VALUE
+      actionValue = multihopHdr.GetAction();
+      switch (multihopHdr.GetCategory())
+        {
+        case WifiMeshMultihopActionHeader::MESH_PEER_LINK_MGT:
+        {
+          Mac48Address peerAddress;
+          MeshMgtPeerLinkManFrame peer_frame;
+          if (hdr->GetAddr1 () != GetAddress ())
+            return;
+          peerAddress = hdr->GetAddr2();
+          packet->RemoveHeader (peer_frame);
+          if (actionValue.peerLink != WifiMeshMultihopActionHeader::PEER_LINK_CLOSE)
+            {
+              //check Supported Rates
+              SupportedRates rates = peer_frame.GetSupportedRates();
+              for (uint32_t i = 0; i < m_stationManager->GetNBasicModes (); i++)
+                {
+                  WifiMode mode = m_stationManager->GetBasicMode (i);
+                  if (!rates.IsSupportedRate (mode.GetDataRate ()))
+                    {
+                      m_peerManager->ConfigurationMismatch(GetAddress(), peerAddress);
+                      return;
+                    }
+                }
+              //Check SSID
+              if (!peer_frame.GetMeshId().IsEqual(GetSsid()))
+                {
+                  m_peerManager->ConfigurationMismatch(GetAddress(), peerAddress);
+                  return;
+                }
+            }
+          switch (actionValue.peerLink)
+            {
+            case WifiMeshMultihopActionHeader::PEER_LINK_CONFIRM:
+              m_peerManager->SetConfirmReceived(
+                GetAddress(),
+                peerAddress,
+                peer_frame.GetAid(),
+                peer_frame.GetPeerLinkManagementElement(),
+                m_meshConfig
+              );
+              return;
+            case WifiMeshMultihopActionHeader::PEER_LINK_OPEN:
+              m_peerManager->SetOpenReceived(
+                GetAddress(),
+                peerAddress,
+                peer_frame.GetPeerLinkManagementElement(),
+                m_meshConfig
+              );
+              return;
+            case WifiMeshMultihopActionHeader::PEER_LINK_CLOSE:
+              m_peerManager->SetCloseReceived(
+                GetAddress(),
+                peerAddress,
+                peer_frame.GetPeerLinkManagementElement()
+              );
+              return;
+            default:
+              return;
+            }
+          break;
+        }
+        case WifiMeshMultihopActionHeader::MESH_PATH_SELECTION:
+        {
+          if (!m_peerManager->IsActiveLink(GetAddress(), hdr->GetAddr2()))
+            return;
+          switch (actionValue.pathSelection)
+            {
+            case WifiMeshMultihopActionHeader::PATH_REQUEST:
+            {
+              WifiPreqInformationElement preq;
+              packet->RemoveHeader(preq);
+              //TODO:recalculate
+              //metric
+              m_preqReceived(preq, hdr->GetAddr2(), CalculateMetric(hdr->GetAddr2()));
+              return;
+            }
+            case WifiMeshMultihopActionHeader::PATH_REPLY:
+            {
+              WifiPrepInformationElement prep;
+              packet->RemoveHeader(prep);
+              m_prepReceived(prep, hdr->GetAddr2(), CalculateMetric(hdr->GetAddr2()));
+            }
+            return;
+            case WifiMeshMultihopActionHeader::PATH_ERROR:
+            {
+              WifiPerrInformationElement perr;
+              packet->RemoveHeader(perr);
+              m_perrReceived(perr, hdr->GetAddr2());
+            }
+            return;
+            case WifiMeshMultihopActionHeader::ROOT_ANNOUNCEMENT:
+              return;
+            }
+        }
+        default:
+          break;
+        }
+    }
+  if (hdr->IsData())
+    {
+      NS_ASSERT((hdr->IsFromDs()) && (hdr->IsToDs()));
+      NS_ASSERT(hdr->GetAddr4()!=Mac48Address::GetBroadcast());
+      //check seqno
+      WifiMeshHeader meshHdr;
+      packet->RemoveHeader(meshHdr);
+      NS_LOG_DEBUG(
+        "DATA TA="<< hdr->GetAddr2()<<
+        ", da="<<hdr->GetAddr3()<<
+        ", sa="<<hdr->GetAddr4()<<
+        ", TTL="<<(int)meshHdr.GetMeshTtl());
+      HwmpTag tag;
+      //mesh header is present within DATA and multihop action frames, so it must be done within MAC
+      tag.SetSeqno(meshHdr.GetMeshSeqno());
+      tag.SetAddress(hdr->GetAddr2());
+      tag.SetTtl(meshHdr.GetMeshTtl());
+      //metric should be later
+      packet->RemoveAllTags();
+      packet->AddTag(tag);
+      if (m_peerManager->IsActiveLink(GetAddress(), hdr->GetAddr2()))
+        ForwardUp(packet, hdr->GetAddr4(), hdr->GetAddr3());
+    }
 }
 
 Time
 MeshWifiMac::CalcSwDelay()
 {
-	UniformVariable coefficient(0.0, m_softwareDelay.GetSeconds());
-	Time delay = Seconds(coefficient.GetValue());
-	if(delay.GetSeconds() + Simulator::Now().GetSeconds() < m_lastMgtFrame.GetSeconds())
-		delay = Seconds(m_lastMgtFrame.GetSeconds() - Simulator::Now().GetSeconds());
-	m_lastMgtFrame = Seconds(Simulator::Now().GetSeconds()+delay.GetSeconds());
-	NS_ASSERT(delay.GetSeconds() >= 0);
-	return delay;
+  UniformVariable coefficient(0.0, m_softwareDelay.GetSeconds());
+  Time delay = Seconds(coefficient.GetValue());
+  if (delay.GetSeconds() + Simulator::Now().GetSeconds() < m_lastMgtFrame.GetSeconds())
+    delay = Seconds(m_lastMgtFrame.GetSeconds() - Simulator::Now().GetSeconds());
+  m_lastMgtFrame = Seconds(Simulator::Now().GetSeconds()+delay.GetSeconds());
+  NS_ASSERT(delay.GetSeconds() >= 0);
+  return delay;
 }
 
 void
 MeshWifiMac::SendPeerLinkOpen(PeerLinkManagementElement peer_element, Mac48Address peerAddress)
 {
-	MeshMgtPeerLinkManFrame open;
-	open.SetOpen();
-	open.SetMeshConfigurationElement(m_meshConfig);
-	open.SetPeerLinkManagementElement(peer_element);
-	Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePeerLinkFrame, this, open, peerAddress);
+  MeshMgtPeerLinkManFrame open;
+  open.SetOpen();
+  open.SetMeshConfigurationElement(m_meshConfig);
+  open.SetPeerLinkManagementElement(peer_element);
+  Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePeerLinkFrame, this, open, peerAddress);
 }
 
 void
 MeshWifiMac::SendPeerLinkConfirm(PeerLinkManagementElement peer_element, Mac48Address peerAddress, uint16_t aid)
-{	
-	MeshMgtPeerLinkManFrame confirm;
-	confirm.SetConfirm();
-	confirm.SetMeshConfigurationElement(m_meshConfig);
-	confirm.SetPeerLinkManagementElement(peer_element);
-	confirm.SetAid(aid);
-	Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePeerLinkFrame, this, confirm, peerAddress);
+{
+  MeshMgtPeerLinkManFrame confirm;
+  confirm.SetConfirm();
+  confirm.SetMeshConfigurationElement(m_meshConfig);
+  confirm.SetPeerLinkManagementElement(peer_element);
+  confirm.SetAid(aid);
+  Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePeerLinkFrame, this, confirm, peerAddress);
 
 }
 
 void
 MeshWifiMac::SendPeerLinkClose(PeerLinkManagementElement peer_element, Mac48Address peerAddress)
 {
-	MeshMgtPeerLinkManFrame close;
-	close.SetClose();
-	close.SetMeshConfigurationElement(m_meshConfig);
-	close.SetPeerLinkManagementElement(peer_element);
-	Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePeerLinkFrame, this, close, peerAddress);
+  MeshMgtPeerLinkManFrame close;
+  close.SetClose();
+  close.SetMeshConfigurationElement(m_meshConfig);
+  close.SetPeerLinkManagementElement(peer_element);
+  Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePeerLinkFrame, this, close, peerAddress);
 
 }
 
 void
 MeshWifiMac::PeerLinkStatus(Mac48Address peerAddress, bool status)
 {
-	//pass information to HwmpState
-	m_peerStatusCallback(peerAddress, status, CalculateMetric(peerAddress));
+  //pass information to HwmpState
+  m_peerStatusCallback(peerAddress, status, CalculateMetric(peerAddress));
 }
 void
 MeshWifiMac::QueuePeerLinkFrame(MeshMgtPeerLinkManFrame peer_frame, Mac48Address peerAddress)
 {
-	Ptr<Packet> packet = Create<Packet> ();
-	//Setting peer frame:
-	peer_frame.SetSupportedRates(GetSupportedRates ());
-	peer_frame.SetQosField(0);
-	peer_frame.SetMeshId(GetSsid());
-	packet->AddHeader (peer_frame);
-	//multihop header:
-	WifiMeshMultihopActionHeader multihopHdr;
-	if(peer_frame.IsOpen())
-	{
-		WifiMeshMultihopActionHeader::ACTION_VALUE action;
-		action.peerLink = WifiMeshMultihopActionHeader::PEER_LINK_OPEN;
-		multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PEER_LINK_MGT, action);
-	}
-	if(peer_frame.IsConfirm())
-	{
-		WifiMeshMultihopActionHeader::ACTION_VALUE action;
-		action.peerLink = WifiMeshMultihopActionHeader::PEER_LINK_CONFIRM;
-		multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PEER_LINK_MGT, action);
-	}
-	if(peer_frame.IsClose())
-	{
-		WifiMeshMultihopActionHeader::ACTION_VALUE action;
-		action.peerLink = WifiMeshMultihopActionHeader::PEER_LINK_CLOSE;
-		multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PEER_LINK_MGT, action);
-	}
-	packet->AddHeader(multihopHdr);
-	//mesh header:
-	WifiMeshHeader meshHdr;
-	meshHdr.SetMeshTtl(1);
-	meshHdr.SetMeshSeqno(0);
-	packet->AddHeader(meshHdr);
-	//Wifi Mac header:
-	WifiMacHeader hdr;
-	hdr.SetMultihopAction();
-	hdr.SetAddr1 (peerAddress);
-	hdr.SetAddr2 (GetAddress ());
-	hdr.SetAddr3 (GetAddress ());
-	hdr.SetDsNotFrom ();
-	hdr.SetDsNotTo ();
-	//queue:
-	m_VO->Queue(packet,hdr);
+  Ptr<Packet> packet = Create<Packet> ();
+  //Setting peer frame:
+  peer_frame.SetSupportedRates(GetSupportedRates ());
+  peer_frame.SetQosField(0);
+  peer_frame.SetMeshId(GetSsid());
+  packet->AddHeader (peer_frame);
+  //multihop header:
+  WifiMeshMultihopActionHeader multihopHdr;
+  if (peer_frame.IsOpen())
+    {
+      WifiMeshMultihopActionHeader::ACTION_VALUE action;
+      action.peerLink = WifiMeshMultihopActionHeader::PEER_LINK_OPEN;
+      multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PEER_LINK_MGT, action);
+    }
+  if (peer_frame.IsConfirm())
+    {
+      WifiMeshMultihopActionHeader::ACTION_VALUE action;
+      action.peerLink = WifiMeshMultihopActionHeader::PEER_LINK_CONFIRM;
+      multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PEER_LINK_MGT, action);
+    }
+  if (peer_frame.IsClose())
+    {
+      WifiMeshMultihopActionHeader::ACTION_VALUE action;
+      action.peerLink = WifiMeshMultihopActionHeader::PEER_LINK_CLOSE;
+      multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PEER_LINK_MGT, action);
+    }
+  packet->AddHeader(multihopHdr);
+  //mesh header:
+  WifiMeshHeader meshHdr;
+  meshHdr.SetMeshTtl(1);
+  meshHdr.SetMeshSeqno(0);
+  packet->AddHeader(meshHdr);
+  //Wifi Mac header:
+  WifiMacHeader hdr;
+  hdr.SetMultihopAction();
+  hdr.SetAddr1 (peerAddress);
+  hdr.SetAddr2 (GetAddress ());
+  hdr.SetAddr3 (GetAddress ());
+  hdr.SetDsNotFrom ();
+  hdr.SetDsNotTo ();
+  //queue:
+  m_VO->Queue(packet,hdr);
 }
 
 void
 MeshWifiMac::SetSoftwareDelay(Time delay)
 {
-	m_softwareDelay = delay;
+  m_softwareDelay = delay;
 }
 
 Time
 MeshWifiMac::GetSoftwareDelay()
 {
-	return m_softwareDelay;
+  return m_softwareDelay;
 }
 
 void
 MeshWifiMac::SendPreq(const WifiPreqInformationElement& preq)
 {
-	//Add a PREQ
-	Ptr<Packet> packet = Create<Packet> ();
-	packet->AddHeader(preq);
-	//Add a Action values:
-	WifiMeshMultihopActionHeader multihopHdr;
-	WifiMeshMultihopActionHeader::ACTION_VALUE action;
-	action.pathSelection = WifiMeshMultihopActionHeader::PATH_REQUEST;
-	multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PATH_SELECTION, action);
-	packet->AddHeader(multihopHdr);
-	//Add a mesh Header
-	WifiMeshHeader meshHdr;
-	//TODO: normal seqno!
-	meshHdr.SetMeshTtl(1);
-	meshHdr.SetMeshSeqno(0);
-	packet->AddHeader(meshHdr);
-	//Add a wifi header:
-	WifiMacHeader hdr;
-	hdr.SetMultihopAction();
-	hdr.SetAddr1 (Mac48Address::GetBroadcast ());
-	hdr.SetAddr2 (GetAddress ());
-	hdr.SetAddr3 (Mac48Address("00:00:00:00:00:00"));
-	hdr.SetDsNotFrom ();
-	hdr.SetDsNotTo ();
-	Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePathSelectionFrame, this, packet, hdr);
-	//m_VO->Queue(packet,hdr);
+  //Add a PREQ
+  Ptr<Packet> packet = Create<Packet> ();
+  packet->AddHeader(preq);
+  //Add a Action values:
+  WifiMeshMultihopActionHeader multihopHdr;
+  WifiMeshMultihopActionHeader::ACTION_VALUE action;
+  action.pathSelection = WifiMeshMultihopActionHeader::PATH_REQUEST;
+  multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PATH_SELECTION, action);
+  packet->AddHeader(multihopHdr);
+  //Add a mesh Header
+  WifiMeshHeader meshHdr;
+  //TODO: normal seqno!
+  meshHdr.SetMeshTtl(1);
+  meshHdr.SetMeshSeqno(0);
+  packet->AddHeader(meshHdr);
+  //Add a wifi header:
+  WifiMacHeader hdr;
+  hdr.SetMultihopAction();
+  hdr.SetAddr1 (Mac48Address::GetBroadcast ());
+  hdr.SetAddr2 (GetAddress ());
+  hdr.SetAddr3 (Mac48Address("00:00:00:00:00:00"));
+  hdr.SetDsNotFrom ();
+  hdr.SetDsNotTo ();
+  Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePathSelectionFrame, this, packet, hdr);
+  //m_VO->Queue(packet,hdr);
 
 }
 
 void
 MeshWifiMac::SendPrep(const WifiPrepInformationElement& prep, const Mac48Address& to)
 {
-	if(!m_peerManager->IsActiveLink(GetAddress(), to))
-		return;
-	Ptr<Packet> packet = Create<Packet> ();
-	packet->AddHeader(prep);
-	//Add a Action values:
-	WifiMeshMultihopActionHeader multihopHdr;
-	WifiMeshMultihopActionHeader::ACTION_VALUE action;
-	action.pathSelection = WifiMeshMultihopActionHeader::PATH_REPLY;
-	multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PATH_SELECTION, action);
-	packet->AddHeader(multihopHdr);
-	//Add a mesh Header
-	WifiMeshHeader meshHdr;
-	//TODO: normal seqno!
-	meshHdr.SetMeshTtl(1);
-	meshHdr.SetMeshSeqno(0);
-	packet->AddHeader(meshHdr);
-	//Add a wifi header:
-	WifiMacHeader hdr;
-	hdr.SetMultihopAction();
-	hdr.SetDsNotTo();
-	hdr.SetDsNotFrom();
-	hdr.SetAddr1(to);
-	hdr.SetAddr2(GetAddress());
-	hdr.SetAddr3(Mac48Address("00:00:00:00:00:00"));
-	//m_VO->Queue(packet,hdr);
-	Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePathSelectionFrame, this, packet, hdr);
+  if (!m_peerManager->IsActiveLink(GetAddress(), to))
+    return;
+  Ptr<Packet> packet = Create<Packet> ();
+  packet->AddHeader(prep);
+  //Add a Action values:
+  WifiMeshMultihopActionHeader multihopHdr;
+  WifiMeshMultihopActionHeader::ACTION_VALUE action;
+  action.pathSelection = WifiMeshMultihopActionHeader::PATH_REPLY;
+  multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PATH_SELECTION, action);
+  packet->AddHeader(multihopHdr);
+  //Add a mesh Header
+  WifiMeshHeader meshHdr;
+  //TODO: normal seqno!
+  meshHdr.SetMeshTtl(1);
+  meshHdr.SetMeshSeqno(0);
+  packet->AddHeader(meshHdr);
+  //Add a wifi header:
+  WifiMacHeader hdr;
+  hdr.SetMultihopAction();
+  hdr.SetDsNotTo();
+  hdr.SetDsNotFrom();
+  hdr.SetAddr1(to);
+  hdr.SetAddr2(GetAddress());
+  hdr.SetAddr3(Mac48Address("00:00:00:00:00:00"));
+  //m_VO->Queue(packet,hdr);
+  Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePathSelectionFrame, this, packet, hdr);
 }
 
 void
 MeshWifiMac::SendPerr(const WifiPerrInformationElement& perr, std::vector<Mac48Address> receivers)
 {
-	NS_ASSERT(receivers.size()!=0);
-	Ptr<Packet> packet = Create<Packet> ();
-	packet->AddHeader(perr);
-	//Add a Action values:
-	WifiMeshMultihopActionHeader multihopHdr;
-	WifiMeshMultihopActionHeader::ACTION_VALUE action;
-	action.pathSelection = WifiMeshMultihopActionHeader::PATH_ERROR;
-	multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PATH_SELECTION, action);
-	packet->AddHeader(multihopHdr);
-	//Add a mesh Header
-	WifiMeshHeader meshHdr;
-	//TODO: normal seqno!
-	meshHdr.SetMeshTtl(1);
-	meshHdr.SetMeshSeqno(0);
-	packet->AddHeader(meshHdr);
-	//Add a wifi header:
-	WifiMacHeader hdr;
-	hdr.SetMultihopAction();
-	hdr.SetDsNotTo();
-	hdr.SetDsNotFrom();
-	hdr.SetAddr2(GetAddress());
-	hdr.SetAddr3(Mac48Address("00:00:00:00:00:00"));
-	//m_VO->Queue(packet,hdr);
-	for(unsigned int i = 0; i < receivers.size(); i ++)
-	{
-		NS_LOG_DEBUG(GetAddress()<<" is sending PERR to "<<receivers[i]);
-		hdr.SetAddr1(receivers[i]);
-		Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePathSelectionFrame, this, packet, hdr);
-	}
+  NS_ASSERT(receivers.size()!=0);
+  Ptr<Packet> packet = Create<Packet> ();
+  packet->AddHeader(perr);
+  //Add a Action values:
+  WifiMeshMultihopActionHeader multihopHdr;
+  WifiMeshMultihopActionHeader::ACTION_VALUE action;
+  action.pathSelection = WifiMeshMultihopActionHeader::PATH_ERROR;
+  multihopHdr.SetAction(WifiMeshMultihopActionHeader::MESH_PATH_SELECTION, action);
+  packet->AddHeader(multihopHdr);
+  //Add a mesh Header
+  WifiMeshHeader meshHdr;
+  //TODO: normal seqno!
+  meshHdr.SetMeshTtl(1);
+  meshHdr.SetMeshSeqno(0);
+  packet->AddHeader(meshHdr);
+  //Add a wifi header:
+  WifiMacHeader hdr;
+  hdr.SetMultihopAction();
+  hdr.SetDsNotTo();
+  hdr.SetDsNotFrom();
+  hdr.SetAddr2(GetAddress());
+  hdr.SetAddr3(Mac48Address("00:00:00:00:00:00"));
+  //m_VO->Queue(packet,hdr);
+  for (unsigned int i = 0; i < receivers.size(); i ++)
+    {
+      NS_LOG_DEBUG(GetAddress()<<" is sending PERR to "<<receivers[i]);
+      hdr.SetAddr1(receivers[i]);
+      Simulator::Schedule(CalcSwDelay() ,&MeshWifiMac::QueuePathSelectionFrame, this, packet, hdr);
+    }
 }
 void
 MeshWifiMac::QueuePathSelectionFrame(Ptr<Packet> packet, const WifiMacHeader hdr)
 {
-	m_VO->Queue(packet, hdr);
+  m_VO->Queue(packet, hdr);
 }
 void
 MeshWifiMac::SetPreqReceivedCallback(
-		Callback<void, WifiPreqInformationElement&, const Mac48Address&, const uint32_t&> cb)
+  Callback<void, WifiPreqInformationElement&, const Mac48Address&, const uint32_t&> cb)
 {
-	m_preqReceived = cb;
+  m_preqReceived = cb;
 }
 
 void
 MeshWifiMac::SetPrepReceivedCallback(
-		Callback<void, WifiPrepInformationElement&, const Mac48Address&, const uint32_t&> cb)
+  Callback<void, WifiPrepInformationElement&, const Mac48Address&, const uint32_t&> cb)
 {
-	m_prepReceived = cb;
+  m_prepReceived = cb;
 }
 
 void
 MeshWifiMac::SetPerrReceivedCallback(
-		Callback<void, WifiPerrInformationElement&, const Mac48Address&> cb)
+  Callback<void, WifiPerrInformationElement&, const Mac48Address&> cb)
 {
-	m_perrReceived = cb;
+  m_perrReceived = cb;
 }
 
 void
 MeshWifiMac::SetPeerStatusCallback(
-		Callback<void, Mac48Address, bool, uint32_t> cb)
+  Callback<void, Mac48Address, bool, uint32_t> cb)
 {
-	m_peerStatusCallback = cb;
+  m_peerStatusCallback = cb;
 }
 
 uint32_t
 MeshWifiMac::CalculateMetric(Mac48Address peerAddress)
 {
-	//suppose Bt == 1000 bytes;
-	uint32_t testLength = 1000;
-	WifiRemoteStation *peerSta = m_stationManager->Lookup (peerAddress);
-	WifiTxStatistics::RATE_LENGTH_STAT stats = peerSta->GetTxStat().statistics;
-	Time overhead = m_sifs  + MicroSeconds(32) + MicroSeconds(8);
-	uint32_t metric = (uint32_t)((double)overhead.GetNanoSeconds()/102.4);
-	uint32_t maxRate = 0;
-	uint32_t packet_sent = 0;
-	for(WifiTxStatistics::RATE_LENGTH_STAT::iterator lengthPos = stats.begin(); lengthPos !=stats.end(); lengthPos++)
-	{
-		if(lengthPos->first > testLength)
-			continue;
-		for(
-				WifiTxStatistics::RATE_STAT::iterator ratePos = lengthPos->second.begin();
-				ratePos != lengthPos->second.end();
-				ratePos ++
-				)
-		{
+  //suppose Bt == 1000 bytes;
+  uint32_t testLength = 1000;
+  WifiRemoteStation *peerSta = m_stationManager->Lookup (peerAddress);
+  WifiTxStatistics::RATE_LENGTH_STAT stats = peerSta->GetTxStat().statistics;
+  Time overhead = m_sifs  + MicroSeconds(32) + MicroSeconds(8);
+  uint32_t metric = (uint32_t)((double)overhead.GetNanoSeconds()/102.4);
+  uint32_t maxRate = 0;
+  uint32_t packet_sent = 0;
+  for (WifiTxStatistics::RATE_LENGTH_STAT::iterator lengthPos = stats.begin(); lengthPos !=stats.end(); lengthPos++)
+    {
+      if (lengthPos->first > testLength)
+        continue;
+      for (
+        WifiTxStatistics::RATE_STAT::iterator ratePos = lengthPos->second.begin();
+        ratePos != lengthPos->second.end();
+        ratePos ++
+      )
+        {
 #if 0
-			NS_LOG_DEBUG("Rate is "<<ratePos->first
-					<<": SUCCESS = "<<ratePos->second.packetsAcked
-					<<", RRETRY = " <<ratePos->second.packetsRetried
-					<<", FAILURE = "<<ratePos->second.packetsFailed);
+          NS_LOG_DEBUG("Rate is "<<ratePos->first
+                       <<": SUCCESS = "<<ratePos->second.packetsAcked
+                       <<", RRETRY = " <<ratePos->second.packetsRetried
+                       <<", FAILURE = "<<ratePos->second.packetsFailed);
 #endif
-			double coefficient = 
-				(double)(
-						ratePos->second.packetsRetried
-						+ ratePos->second.packetsAcked
-					)/((double)ratePos->second.packetsAcked);
-			uint16_t avgLength = 0;
-			if(ratePos->second.packetsAcked == 0)
-				avgLength = lengthPos->first;
-			else
-				avgLength = ratePos->second.bytesAcked/ratePos->second.packetsAcked;
-			uint32_t payload = (uint32_t)((double)avgLength / ((double)ratePos->first)*1e9);
-			if(packet_sent < ratePos->second.packetsAcked)
-			{
-				metric = (uint32_t)(coefficient*((double)overhead.GetNanoSeconds() + (double)payload)/10240);
-				packet_sent = ratePos->second.packetsAcked;
-				maxRate = ratePos->first;
-			}
-		}
-	}
+          double coefficient =
+            (double)(
+              ratePos->second.packetsRetried
+              + ratePos->second.packetsAcked
+            )/((double)ratePos->second.packetsAcked);
+          uint16_t avgLength = 0;
+          if (ratePos->second.packetsAcked == 0)
+            avgLength = lengthPos->first;
+          else
+            avgLength = ratePos->second.bytesAcked/ratePos->second.packetsAcked;
+          uint32_t payload = (uint32_t)((double)avgLength / ((double)ratePos->first)*1e9);
+          if (packet_sent < ratePos->second.packetsAcked)
+            {
+              metric = (uint32_t)(coefficient*((double)overhead.GetNanoSeconds() + (double)payload)/10240);
+              packet_sent = ratePos->second.packetsAcked;
+              maxRate = ratePos->first;
+            }
+        }
+    }
 
-	//NS_LOG_DEBUG("RATE is "<<maxRate<<" metric is "<<metric);
-	//peerSta->ResetTxStat();
-	NS_ASSERT(metric !=0);
-	return metric;
+  //NS_LOG_DEBUG("RATE is "<<maxRate<<" metric is "<<metric);
+  //peerSta->ResetTxStat();
+  NS_ASSERT(metric !=0);
+  return metric;
 }
 
 } // namespace ns3
diff --git a/src/devices/wifi/mesh-wifi-mac.h b/src/devices/wifi/mesh-wifi-mac.h
index 9c36b2ace..164b72217 100644
--- a/src/devices/wifi/mesh-wifi-mac.h
+++ b/src/devices/wifi/mesh-wifi-mac.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -38,348 +38,347 @@
 
 namespace ns3 {
 
-	class WifiMacHeader;
-	class DcaTxop;
-	class WifiPhy;
-	class DcfManager;
-	class MacRxMiddle;
-	class MacLow;
-	class WifiPeerManager;
-	/**
-	 * \ingroup mesh
-	 * 
-	 * \brief Implements MAC-layer of mesh point: beaconing and
-	 * peer link management.
-	 *
-	 * \details Handles sending and receiving beacons. Tells all
-	 * needed information about beacons to MeshWifiPeerManager class, which
-	 * handles peer link management state machine. Asks
-	 * WifiPeerManager wether
-	 * receive or discard frame obtained from neighbour.
-	 * Now only three output queues are used: 
-	 * one for beacons (PIFS and no backoff),
-	 * one for background traffic,
-	 * one for management and priority traffic.
-	 */
-	class MeshWifiMac : public WifiMac
-	{
-		public:
-			static TypeId		GetTypeId ();
+class WifiMacHeader;
+class DcaTxop;
+class WifiPhy;
+class DcfManager;
+class MacRxMiddle;
+class MacLow;
+class WifiPeerManager;
+/**
+ * \ingroup mesh
+ *
+ * \brief Implements MAC-layer of mesh point: beaconing and
+ * peer link management.
+ *
+ * \details Handles sending and receiving beacons. Tells all
+ * needed information about beacons to MeshWifiPeerManager class, which
+ * handles peer link management state machine. Asks
+ * WifiPeerManager wether
+ * receive or discard frame obtained from neighbour.
+ * Now only three output queues are used:
+ * one for beacons (PIFS and no backoff),
+ * one for background traffic,
+ * one for management and priority traffic.
+ */
+class MeshWifiMac : public WifiMac
+{
+public:
+  static TypeId  GetTypeId ();
 
-			MeshWifiMac ();
-			~MeshWifiMac ();
-			// inherited from WifiMac.
-			virtual void		SetSlot (Time slotTime);
-			virtual void		SetSifs (Time sifs);
-			virtual void		SetPifs (Time pifs);
-  			virtual void		SetCtsTimeout (Time ctsTimeout);
-  			virtual void		SetAckTimeout (Time ackTimeout);
-			virtual void		SetEifsNoDifs (Time eifsNoDifs);
-			virtual Time		GetSlot () const;
-			virtual Time		GetSifs () const;
-			virtual Time		GetPifs () const;
-  			virtual Time		GetCtsTimeout () const;
-  			virtual Time		GetAckTimeout () const;
-			virtual Time		GetEifsNoDifs () const;
-			virtual void		SetWifiPhy (Ptr<WifiPhy> phy);
-			virtual void		SetWifiRemoteStationManager (Ptr<WifiRemoteStationManager> stationManager);
-  			virtual void		Enqueue (Ptr<const Packet> packet, Mac48Address to, Mac48Address from);
-			virtual void		Enqueue (Ptr<const Packet> packet, Mac48Address to);
-  			virtual bool		SupportsSendFrom () const;
-  			virtual void		SetForwardUpCallback (Callback<void,Ptr<Packet>, Mac48Address, Mac48Address> upCallback);
-			virtual void		SetLinkUpCallback (Callback<void> linkUp);
-			virtual void		SetLinkDownCallback (Callback<void> linkDown);
-			virtual	Mac48Address	GetAddress () const;
-			virtual Mac48Address	GetBssid () const;
-			virtual Ssid		GetSsid () const;
-			virtual void		SetAddress (Mac48Address address);
-			virtual void		SetSsid (Ssid ssid);
-			/**
-			 * \param interval is an interval between two
-			 * successive beacons
-			 */
-			void			SetBeaconInterval (Time interval);
-			/**
-			 * \returns interval between two beacons
-			 */
-			Time			GetBeaconInterval () const;
-			/**
-			 * \param delay is the maximum software delay.
-			 *
-			 * \details Software delay is calculated as uniformely
-			 * distributed random value between zero and
-			 * given parameter.
-			 *
-			 * All management frames are sent after software delay is passed,
-			 * for example, beacon is formed at software
-			 * delay before putting it to the queue.
-			 *
-			 * \attention The software delay is supposed
-			 * to be independent from traffic intensity.
-			 *
-			 */
-			void			SetSoftwareDelay(Time delay);
-			/**
-			 * \returns software delay parameter
-			 */
-			Time			GetSoftwareDelay();
-			/**
-			 * \param manager is pointer to the
-			 * WifiPeerManager class, which implements
-			 * peer-link management state machine.
-			 *
-			 * \details The purpose of peer manager is
-			 * obtaining all needed information from
-			 * beacons and send peer link management
-			 * frames.
-			 *
-			 * This funcion sets all needed callbacks to
-			 * a given peer manager
-			 */
-                        void                    SetPeerLinkManager(Ptr<WifiPeerManager> manager);
-			virtual void		SetPreqReceivedCallback(
-					Callback<void, WifiPreqInformationElement&, const Mac48Address&, const uint32_t&> cb);
-			/**
-			 * \brief this callback is set by Hwmp routing
-			 * protocol and executed when MAC has received
-			 * PREP.
-			 * \param cb is a callback to be executed when
-			 * receiving PREP.
-			 */
-			virtual void		SetPrepReceivedCallback(
-					Callback<void, WifiPrepInformationElement&, const Mac48Address&, const uint32_t&> cb);
-			/**
-			 * \brief this callback is set by Hwmp routing
-			 * protocol and executed when MAC has received
-			 * PERR.
-			 * \param cb is a callback to be executed when
-			 * receiving PERR.
-			 */
-			virtual void		SetPerrReceivedCallback(
-					Callback<void, WifiPerrInformationElement&, const Mac48Address&> cb);
+  MeshWifiMac ();
+  ~MeshWifiMac ();
+  // inherited from WifiMac.
+  virtual void  SetSlot (Time slotTime);
+  virtual void  SetSifs (Time sifs);
+  virtual void  SetPifs (Time pifs);
+  virtual void  SetCtsTimeout (Time ctsTimeout);
+  virtual void  SetAckTimeout (Time ackTimeout);
+  virtual void  SetEifsNoDifs (Time eifsNoDifs);
+  virtual Time  GetSlot () const;
+  virtual Time  GetSifs () const;
+  virtual Time  GetPifs () const;
+  virtual Time  GetCtsTimeout () const;
+  virtual Time  GetAckTimeout () const;
+  virtual Time  GetEifsNoDifs () const;
+  virtual void  SetWifiPhy (Ptr<WifiPhy> phy);
+  virtual void  SetWifiRemoteStationManager (Ptr<WifiRemoteStationManager> stationManager);
+  virtual void  Enqueue (Ptr<const Packet> packet, Mac48Address to, Mac48Address from);
+  virtual void  Enqueue (Ptr<const Packet> packet, Mac48Address to);
+  virtual bool  SupportsSendFrom () const;
+  virtual void  SetForwardUpCallback (Callback<void,Ptr<Packet>, Mac48Address, Mac48Address> upCallback);
+  virtual void  SetLinkUpCallback (Callback<void> linkUp);
+  virtual void  SetLinkDownCallback (Callback<void> linkDown);
+  virtual Mac48Address GetAddress () const;
+  virtual Mac48Address GetBssid () const;
+  virtual Ssid  GetSsid () const;
+  virtual void  SetAddress (Mac48Address address);
+  virtual void  SetSsid (Ssid ssid);
+  /**
+   * \param interval is an interval between two
+   * successive beacons
+   */
+  void   SetBeaconInterval (Time interval);
+  /**
+   * \returns interval between two beacons
+   */
+  Time   GetBeaconInterval () const;
+  /**
+   * \param delay is the maximum software delay.
+   *
+   * \details Software delay is calculated as uniformely
+   * distributed random value between zero and
+   * given parameter.
+   *
+   * All management frames are sent after software delay is passed,
+   * for example, beacon is formed at software
+   * delay before putting it to the queue.
+   *
+   * \attention The software delay is supposed
+   * to be independent from traffic intensity.
+   *
+   */
+  void   SetSoftwareDelay(Time delay);
+  /**
+   * \returns software delay parameter
+   */
+  Time   GetSoftwareDelay();
+  /**
+   * \param manager is pointer to the
+   * WifiPeerManager class, which implements
+   * peer-link management state machine.
+   *
+   * \details The purpose of peer manager is
+   * obtaining all needed information from
+   * beacons and send peer link management
+   * frames.
+   *
+   * This funcion sets all needed callbacks to
+   * a given peer manager
+   */
+  void          SetPeerLinkManager(Ptr<WifiPeerManager> manager);
+  virtual void  SetPreqReceivedCallback(
+    Callback<void, WifiPreqInformationElement&, const Mac48Address&, const uint32_t&> cb);
+  /**
+   * \brief this callback is set by Hwmp routing
+   * protocol and executed when MAC has received
+   * PREP.
+   * \param cb is a callback to be executed when
+   * receiving PREP.
+   */
+  virtual void  SetPrepReceivedCallback(
+    Callback<void, WifiPrepInformationElement&, const Mac48Address&, const uint32_t&> cb);
+  /**
+   * \brief this callback is set by Hwmp routing
+   * protocol and executed when MAC has received
+   * PERR.
+   * \param cb is a callback to be executed when
+   * receiving PERR.
+   */
+  virtual void  SetPerrReceivedCallback(
+    Callback<void, WifiPerrInformationElement&, const Mac48Address&> cb);
 
-			/**
-			 * \brief this callback is set by Hwmp routing
-			 * protocol and executed when MAC has detected
-			 * the peer link failure
-			 * \param cb is a callback to be executed when
-			 * peer failure has ben detected
-			 */
-			virtual void            SetPeerStatusCallback(
-					Callback<void, Mac48Address, bool, uint32_t> cb);
-			/**
-			 * \brief Sends a PREQ frame.
-			 * \param preq is preq information element
-			 * formed by protocol. This function just adds
-			 * a proper WifiMacHeader
-			 * \attention This method is public, because
-			 * HWMP makes a callback using this method
-			 */
-			virtual void		SendPreq(const WifiPreqInformationElement& preq);
-			/**
-			 * \brief Sends a PREP frame.
-			 * \param prep is prep information element
-			 * formed by protocol. This function just adds
-			 * a proper WifiMacHeader
-			 * \param to is an address of retransmitter of
-			 * the prep
-			 * \attention This method is public, because
-			 * HWMP makes a callback using this method
-			 */
+  /**
+   * \brief this callback is set by Hwmp routing
+   * protocol and executed when MAC has detected
+   * the peer link failure
+   * \param cb is a callback to be executed when
+   * peer failure has ben detected
+   */
+  virtual void            SetPeerStatusCallback(
+    Callback<void, Mac48Address, bool, uint32_t> cb);
+  /**
+   * \brief Sends a PREQ frame.
+   * \param preq is preq information element
+   * formed by protocol. This function just adds
+   * a proper WifiMacHeader
+   * \attention This method is public, because
+   * HWMP makes a callback using this method
+   */
+  virtual void  SendPreq(const WifiPreqInformationElement& preq);
+  /**
+   * \brief Sends a PREP frame.
+   * \param prep is prep information element
+   * formed by protocol. This function just adds
+   * a proper WifiMacHeader
+   * \param to is an address of retransmitter of
+   * the prep
+   * \attention This method is public, because
+   * HWMP makes a callback using this method
+   */
 
-			virtual void		SendPrep(const WifiPrepInformationElement& prep, const Mac48Address& to);
-			/**
-			 * \brief Sends a PERR frame.
-			 * \param perr is perr information element
-			 * formed by protocol. This function just adds
-			 * a proper WifiMacHeader.
-			 * \param receivers is list of addresses where
-			 * to send PERR (unicast PERR case)
-			 * \attention This method is public, because
-			 * HWMP makes a callback using this method
-			 */
-			virtual void		SendPerr(const WifiPerrInformationElement& perr, std::vector<Mac48Address> receivers);
-			/**
-			 * \brief Sends PeerLinkOpen frame to a given
-			 * address. Mac only forms a proper
-			 * WifiMacHeader.
-			 * \param peer_element is peer link frame to
-			 * be sent
-			 * \param peerAddress is the address of
-			 * destination of given frame
-			 */
-			void			SendPeerLinkOpen(
-					PeerLinkManagementElement peer_element,
-					Mac48Address peerAddress
-					);
-			/**
-			 * \brief Sends PeerLinkConfirm frame to a given
-			 * address. Mac only forms a proper
-			 * WifiMacHeader.
-			 * \param peer_element is peer link frame to
-			 * be sent
-			 * \param peerAddress is the address of
-			 * destination of given frame
-			 * \param aid is the assocciation ID stored in
-			 * peer manager
-			 */
-			void			SendPeerLinkConfirm(
-					PeerLinkManagementElement peer_element,
-					Mac48Address peerAddress,
-					uint16_t aid
-					);
-			/**
-			 * \brief Sends PeerLinkClose frame to a given
-			 * address. Mac only forms a proper
-			 * WifiMacHeader.
-			 * \param peer_element is peer link frame to
-			 * be sent
-			 * \param peerAddress is the address of
-			 * destination of given frame
-			 */
-			void			SendPeerLinkClose(
-					PeerLinkManagementElement peer_element,
-					Mac48Address peerAddress
-					);
-			/**
-			 * \brief this method is executed by peer
-			 * manager when peer link opened or closed
-			 * \param status true when link was opened,
-			 * false if link was closed
-			 * \param peerAddress is the address of
-			 * destination of given frame
-			 */
-			virtual void		PeerLinkStatus(Mac48Address peerAddress, bool status);
+  virtual void  SendPrep(const WifiPrepInformationElement& prep, const Mac48Address& to);
+  /**
+   * \brief Sends a PERR frame.
+   * \param perr is perr information element
+   * formed by protocol. This function just adds
+   * a proper WifiMacHeader.
+   * \param receivers is list of addresses where
+   * to send PERR (unicast PERR case)
+   * \attention This method is public, because
+   * HWMP makes a callback using this method
+   */
+  virtual void  SendPerr(const WifiPerrInformationElement& perr, std::vector<Mac48Address> receivers);
+  /**
+   * \brief Sends PeerLinkOpen frame to a given
+   * address. Mac only forms a proper
+   * WifiMacHeader.
+   * \param peer_element is peer link frame to
+   * be sent
+   * \param peerAddress is the address of
+   * destination of given frame
+   */
+  void   SendPeerLinkOpen(
+    PeerLinkManagementElement peer_element,
+    Mac48Address peerAddress
+  );
+  /**
+   * \brief Sends PeerLinkConfirm frame to a given
+   * address. Mac only forms a proper
+   * WifiMacHeader.
+   * \param peer_element is peer link frame to
+   * be sent
+   * \param peerAddress is the address of
+   * destination of given frame
+   * \param aid is the assocciation ID stored in
+   * peer manager
+   */
+  void   SendPeerLinkConfirm(
+    PeerLinkManagementElement peer_element,
+    Mac48Address peerAddress,
+    uint16_t aid
+  );
+  /**
+   * \brief Sends PeerLinkClose frame to a given
+   * address. Mac only forms a proper
+   * WifiMacHeader.
+   * \param peer_element is peer link frame to
+   * be sent
+   * \param peerAddress is the address of
+   * destination of given frame
+   */
+  void   SendPeerLinkClose(
+    PeerLinkManagementElement peer_element,
+    Mac48Address peerAddress
+  );
+  /**
+   * \brief this method is executed by peer
+   * manager when peer link opened or closed
+   * \param status true when link was opened,
+   * false if link was closed
+   * \param peerAddress is the address of
+   * destination of given frame
+   */
+  virtual void  PeerLinkStatus(Mac48Address peerAddress, bool status);
 
-			/**
-			 * \brief Peer Manager notifyes MAC about new
-			 * peer link or peer link failure.
-			 * \details This method should pass this event
-			 * to HWMP, and it should generate new routing
-			 * information or should generate Path Error
-			 * \param peerAddress it the address of
-			 * neighbour
-			 * \param status If true - new peer link, perr
-			 * link failure otherwise
-			 */
-			void			PeerEvent(
-					Mac48Address	peerAddress,
-					bool		status
-					);
-		private:
-			void		Receive (Ptr<Packet> packet, WifiMacHeader const *hdr);
-			virtual void	ForwardUp (Ptr<Packet> packet, Mac48Address src, Mac48Address dst);
-			void		ForwardDown(
-					Ptr<const Packet> packet,
-					Mac48Address from,
-					Mac48Address to
-					);
-			void		TxOk (WifiMacHeader const &hdr);
-			void		TxFailed (WifiMacHeader const &hdr);
-			/**
-			 * \brief At the software delay before TBTT
-			 * SendOneBeacon is ececuted. It forms a
-			 * beacon frame body. Then calculates software
-			 * delay and schedules QueueOneBeacon
-			 */
-			void		SendOneBeacon ();
-			/**
-			 * \brief Puts a formed beacon to the output
-			 * queue. SendOneBeacon forms a beacon and
-			 * after software delay QueueOneBeacon is
-			 * executed
-			 * \param beacon_hdr is beacon to be queued
-			 */
-			void		QueueOneBeacon (MgtMeshBeaconHeader beacon_hdr);
-			/**
-			 * \brief Executed after software delay by
-			 * SendPeerLinkOpen/Confirm/Close frames and
-			 * puts this frame to the output queue.
-			 * \param peer_frame peer link management
-			 * frame
-			 * \param peerAddress the address of
-			 * destination.
-			 */
-			void		QueuePeerLinkFrame(MeshMgtPeerLinkManFrame peer_frame, Mac48Address peerAddress);
-			/**
-			 * \brief Executed after software delay by
-			 * SendPreq/Prep/Perr frames and
-			 * puts this frame to the output queue.
-			 * \param packet is packet body,
-			 * \param hdr is WifiMacHeader
-			 */
-			void		QueuePathSelectionFrame(Ptr<Packet> packet, const WifiMacHeader hdr);
-			void		SetBeaconGeneration (bool enable);
-			bool		GetBeaconGeneration () const;
-			SupportedRates	GetSupportedRates () const;
-			virtual void	DoDispose ();
+  /**
+   * \brief Peer Manager notifyes MAC about new
+   * peer link or peer link failure.
+   * \details This method should pass this event
+   * to HWMP, and it should generate new routing
+   * information or should generate Path Error
+   * \param peerAddress it the address of
+   * neighbour
+   * \param status If true - new peer link, perr
+   * link failure otherwise
+   */
+  void   PeerEvent(
+    Mac48Address peerAddress,
+    bool  status
+  );
+private:
+  void  Receive (Ptr<Packet> packet, WifiMacHeader const *hdr);
+  virtual void ForwardUp (Ptr<Packet> packet, Mac48Address src, Mac48Address dst);
+  void  ForwardDown(
+    Ptr<const Packet> packet,
+    Mac48Address from,
+    Mac48Address to
+  );
+  void  TxOk (WifiMacHeader const &hdr);
+  void  TxFailed (WifiMacHeader const &hdr);
+  /**
+   * \brief At the software delay before TBTT
+   * SendOneBeacon is ececuted. It forms a
+   * beacon frame body. Then calculates software
+   * delay and schedules QueueOneBeacon
+   */
+  void  SendOneBeacon ();
+  /**
+   * \brief Puts a formed beacon to the output
+   * queue. SendOneBeacon forms a beacon and
+   * after software delay QueueOneBeacon is
+   * executed
+   * \param beacon_hdr is beacon to be queued
+   */
+  void  QueueOneBeacon (MgtMeshBeaconHeader beacon_hdr);
+  /**
+   * \brief Executed after software delay by
+   * SendPeerLinkOpen/Confirm/Close frames and
+   * puts this frame to the output queue.
+   * \param peer_frame peer link management
+   * frame
+   * \param peerAddress the address of
+   * destination.
+   */
+  void  QueuePeerLinkFrame(MeshMgtPeerLinkManFrame peer_frame, Mac48Address peerAddress);
+  /**
+   * \brief Executed after software delay by
+   * SendPreq/Prep/Perr frames and
+   * puts this frame to the output queue.
+   * \param packet is packet body,
+   * \param hdr is WifiMacHeader
+   */
+  void  QueuePathSelectionFrame(Ptr<Packet> packet, const WifiMacHeader hdr);
+  void  SetBeaconGeneration (bool enable);
+  bool  GetBeaconGeneration () const;
+  SupportedRates GetSupportedRates () const;
+  virtual void DoDispose ();
 
-			Ptr<DcaTxop>			m_BE;
-			Ptr<DcaTxop>			m_BK;
-			Ptr<DcaTxop>			m_VI;
-			Ptr<DcaTxop>			m_VO;
-			Ptr<DcaTxop>			m_beaconDca;
-			Ptr<WifiRemoteStationManager>	m_stationManager;
-			Ptr<WifiPhy>			m_phy;
-			Callback<void,Ptr<Packet>, Mac48Address, Mac48Address>
-							m_upCallback;
-			Time				m_beaconInterval;
-			Time				m_randomStart;
+  Ptr<DcaTxop>   m_BE;
+  Ptr<DcaTxop>   m_BK;
+  Ptr<DcaTxop>   m_VI;
+  Ptr<DcaTxop>   m_VO;
+  Ptr<DcaTxop>   m_beaconDca;
+  Ptr<WifiRemoteStationManager> m_stationManager;
+  Ptr<WifiPhy>   m_phy;
+  Callback<void,Ptr<Packet>, Mac48Address, Mac48Address>  m_upCallback;
+  Time    m_beaconInterval;
+  Time    m_randomStart;
 
-			DcfManager *			m_dcfManager;
-			MacRxMiddle *			m_rxMiddle;
-			Ptr<MacLow>			m_low;
-			Mac48Address			m_address;
-			Ssid				m_MeshId;
-			EventId				m_beaconFormEvent;
-			EventId				m_beaconSendEvent;
-			Time				m_slot;
-			Time				m_sifs;
-  			Time				m_pifs;
-			Time				m_ackTimeout;
-			Time				m_ctsTimeout;
+  DcfManager    *m_dcfManager;
+  MacRxMiddle   *m_rxMiddle;
+  Ptr<MacLow>    m_low;
+  Mac48Address   m_address;
+  Ssid       m_MeshId;
+  EventId    m_beaconFormEvent;
+  EventId    m_beaconSendEvent;
+  Time    m_slot;
+  Time    m_sifs;
+  Time    m_pifs;
+  Time    m_ackTimeout;
+  Time    m_ctsTimeout;
 
-			Time				m_eifsNoDifs;
-			MeshConfigurationElement	m_meshConfig; //Stores my configuration;
-			//Peer Descriptor pointer:
-			Ptr<WifiPeerManager> 		m_peerManager;
-			Time				m_softwareDelay;
-			/**
-			 * \attention Software delay is used for management
-			 * frames, so, if this delay is calculated
-			 * independenly, the packet order may be
-			 * broken, so the last mgt frame sending time
-			 * should be keeped within MAC
-			 */
-			Time				m_lastMgtFrame;
-			/**
-			 * \returns the value of software delay
-			 * uniformely distributed between 0 and
-			 * m_softwareDealy (initiated by
-			 * SetSoftwareDelay method).
-			 */
-			Time				CalcSwDelay();
-			/**
-			 * \brief keeps delay for sending first
-			 * beacon. this delay is uniformely
-			 * distributed between 0 and given value
-			 */
-			Time				m_beaconFormingRandomDelay;
-			Callback<void, WifiPreqInformationElement&, const Mac48Address&, const uint32_t&>
-							m_preqReceived;
-			Callback<void, WifiPrepInformationElement&, const Mac48Address&, const uint32_t&>
-							m_prepReceived;
-			Callback<void, WifiPerrInformationElement&, const Mac48Address&>
-							m_perrReceived;
-			Callback<void, Mac48Address, bool, uint32_t>
-							m_peerStatusCallback;
-			/**
-			 * \brief metric calculation parameters
-			 */
-			uint32_t			CalculateMetric(Mac48Address peerAddress);
-			std::map<Mac48Address, uint32_t, mac48addrComparator>
-							m_metricDatabase;
-	};
+  Time    m_eifsNoDifs;
+  MeshConfigurationElement m_meshConfig; //Stores my configuration;
+  //Peer Descriptor pointer:
+  Ptr<WifiPeerManager>   m_peerManager;
+  Time    m_softwareDelay;
+  /**
+   * \attention Software delay is used for management
+   * frames, so, if this delay is calculated
+   * independenly, the packet order may be
+   * broken, so the last mgt frame sending time
+   * should be keeped within MAC
+   */
+  Time    m_lastMgtFrame;
+  /**
+   * \returns the value of software delay
+   * uniformely distributed between 0 and
+   * m_softwareDealy (initiated by
+   * SetSoftwareDelay method).
+   */
+  Time    CalcSwDelay();
+  /**
+   * \brief keeps delay for sending first
+   * beacon. this delay is uniformely
+   * distributed between 0 and given value
+   */
+  Time    m_beaconFormingRandomDelay;
+  Callback<void, WifiPreqInformationElement&, const Mac48Address&, const uint32_t&>
+  m_preqReceived;
+  Callback<void, WifiPrepInformationElement&, const Mac48Address&, const uint32_t&>
+  m_prepReceived;
+  Callback<void, WifiPerrInformationElement&, const Mac48Address&>
+  m_perrReceived;
+  Callback<void, Mac48Address, bool, uint32_t>
+  m_peerStatusCallback;
+  /**
+   * \brief metric calculation parameters
+   */
+  uint32_t   CalculateMetric(Mac48Address peerAddress);
+  std::map<Mac48Address, uint32_t, mac48addrComparator>
+  m_metricDatabase;
+};
 
 } // namespace ns3
 
diff --git a/src/devices/wifi/mesh-wifi-peer-manager.cc b/src/devices/wifi/mesh-wifi-peer-manager.cc
index 55a551727..6894190e0 100644
--- a/src/devices/wifi/mesh-wifi-peer-manager.cc
+++ b/src/devices/wifi/mesh-wifi-peer-manager.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -29,957 +29,962 @@
 NS_LOG_COMPONENT_DEFINE ("WifiPeerManager");
 namespace ns3 {
 /***************************************************
- *	PeerLinkDescriptor
+ * PeerLinkDescriptor
  ***************************************************/
 WifiPeerLinkDescriptor::WifiPeerLinkDescriptor():
-	m_localLinkId(0),
-	m_peerLinkId(0),
-	m_state(IDLE),
-	m_retryCounter(0),
-	m_maxBeaconLoss(3)
+    m_localLinkId(0),
+    m_peerLinkId(0),
+    m_state(IDLE),
+    m_retryCounter(0),
+    m_maxBeaconLoss(3)
 {}
 
-	void
+void
 WifiPeerLinkDescriptor::SetPeerAddress(Mac48Address macaddr)
 {
-	m_peerAddress = macaddr;
+  m_peerAddress = macaddr;
 }
 
-	void
+void
 WifiPeerLinkDescriptor::SetLocalAddress(Mac48Address macaddr)
 {
-	m_localAddress = macaddr;
+  m_localAddress = macaddr;
 }
 
-	void
+void
 WifiPeerLinkDescriptor::SetLocalLinkId(uint16_t id)
 {
-	m_localLinkId = id;
+  m_localLinkId = id;
 }
-	void
+void
 WifiPeerLinkDescriptor::SetLocalAid(uint16_t aid)
 {
-	m_assocId = aid;
+  m_assocId = aid;
 }
-	void
+void
 WifiPeerLinkDescriptor::SetBeaconInformation(Time lastBeacon, Time beaconInterval)
 {
-	m_lastBeacon = lastBeacon;
-	m_beaconInterval = beaconInterval;
-	m_beaconLossTimer.Cancel();
-	Time delay = Seconds(beaconInterval.GetSeconds()*m_maxBeaconLoss);
-	NS_ASSERT(delay.GetMicroSeconds()!= 0);
-	m_beaconLossTimer = Simulator::Schedule(delay, &WifiPeerLinkDescriptor::BeaconLoss, this);
+  m_lastBeacon = lastBeacon;
+  m_beaconInterval = beaconInterval;
+  m_beaconLossTimer.Cancel();
+  Time delay = Seconds(beaconInterval.GetSeconds()*m_maxBeaconLoss);
+  NS_ASSERT(delay.GetMicroSeconds()!= 0);
+  m_beaconLossTimer = Simulator::Schedule(delay, &WifiPeerLinkDescriptor::BeaconLoss, this);
 }
 
-	void
+void
 WifiPeerLinkDescriptor::SetMaxBeaconLoss(uint8_t maxBeaconLoss)
 {
-	m_maxBeaconLoss = maxBeaconLoss;
+  m_maxBeaconLoss = maxBeaconLoss;
 }
 
-	void
+void
 WifiPeerLinkDescriptor::SetLinkStatusCallback(Callback<void, Mac48Address, Mac48Address, bool> cb)
 {
-	m_linkStatusCallback = cb;
+  m_linkStatusCallback = cb;
 }
-	void
+void
 WifiPeerLinkDescriptor::BeaconLoss()
 {
-	StateMachine(CNCL);
+  StateMachine(CNCL);
 }
 
-	void
+void
 WifiPeerLinkDescriptor::SetBeaconTimingElement(WifiBeaconTimingElement beaconTiming)
 {
-	m_beaconTiming = beaconTiming;
+  m_beaconTiming = beaconTiming;
 }
 
 Mac48Address
 WifiPeerLinkDescriptor::GetPeerAddress() const
-{
-	return m_peerAddress;
-}
+  {
+    return m_peerAddress;
+  }
 
 Mac48Address
 WifiPeerLinkDescriptor::GetLocalAddress() const
-{
-	return m_localAddress;
-}
+  {
+    return m_localAddress;
+  }
 
 
 uint16_t
 WifiPeerLinkDescriptor::GetLocalAid()const
-{
-	return m_assocId;
-}
+  {
+    return m_assocId;
+  }
 
 Time
 WifiPeerLinkDescriptor::GetLastBeacon() const
-{
-	return m_lastBeacon;
-}
+  {
+    return m_lastBeacon;
+  }
 
 Time
 WifiPeerLinkDescriptor::GetBeaconInterval() const
-{
-	return m_beaconInterval;
-}
+  {
+    return m_beaconInterval;
+  }
 WifiBeaconTimingElement
 WifiPeerLinkDescriptor::GetBeaconTimingElement() const
-{
-	return m_beaconTiming;
-}
+  {
+    return m_beaconTiming;
+  }
 
-	void
+void
 WifiPeerLinkDescriptor::ClearTimingElement()
 {
-	m_beaconTiming.ClearTimingElement();
+  m_beaconTiming.ClearTimingElement();
 }
 
 
 void  WifiPeerLinkDescriptor::MLMECancelPeerLink(dot11sReasonCode reason)
 {
-	StateMachine(CNCL,reason);
+  StateMachine(CNCL,reason);
 }
 
 void  WifiPeerLinkDescriptor::MLMEPassivePeerLinkOpen()
 {
-	StateMachine(PASOPN);
+  StateMachine(PASOPN);
 }
 
 void  WifiPeerLinkDescriptor::MLMEActivePeerLinkOpen()
 {
-	StateMachine(ACTOPN);
+  StateMachine(ACTOPN);
 }
 void WifiPeerLinkDescriptor::MLMEPeeringRequestReject()
 {
-	StateMachine(REQ_RJCT, REASON11S_PEER_LINK_CANCELLED);
+  StateMachine(REQ_RJCT, REASON11S_PEER_LINK_CANCELLED);
 }
 #if 0
 void  WifiPeerLinkDescriptor::MLMEBindSecurityAssociation()
 {
-	StateMachine(BNDSA);
+  StateMachine(BNDSA);
 }
 #endif
-	void
+void
 WifiPeerLinkDescriptor::SetMac(Ptr<MeshWifiMac> mac)
 {
-	m_mac = mac;
+  m_mac = mac;
 }
 void WifiPeerLinkDescriptor::PeerLinkClose(uint16_t localLinkId,uint16_t peerLinkId, dot11sReasonCode reason)
 {
-	if( peerLinkId != 0 && m_localLinkId != peerLinkId)
-		return;
-	if( m_peerLinkId == 0)
-		m_peerLinkId = localLinkId;
-	else if ( m_peerLinkId != localLinkId )
-		return;
-	StateMachine(CLS_ACPT,reason);
+  if (peerLinkId != 0 && m_localLinkId != peerLinkId)
+    return;
+  if (m_peerLinkId == 0)
+    m_peerLinkId = localLinkId;
+  else if (m_peerLinkId != localLinkId)
+    return;
+  StateMachine(CLS_ACPT, reason);
 }
 
 void WifiPeerLinkDescriptor::PeerLinkOpenAccept(uint16_t localLinkId, MeshConfigurationElement  conf)
 {
-	if( m_peerLinkId == 0)
-		m_peerLinkId = localLinkId;
-	m_configuration = conf;
-	StateMachine(OPN_ACPT);
+  if (m_peerLinkId == 0)
+    m_peerLinkId = localLinkId;
+  m_configuration = conf;
+  StateMachine(OPN_ACPT);
 }
 
 void WifiPeerLinkDescriptor::PeerLinkOpenReject(uint16_t localLinkId, MeshConfigurationElement  conf,dot11sReasonCode reason)
 {
-	if( m_peerLinkId == 0)
-		m_peerLinkId = localLinkId;
-	m_configuration = conf; 
-	StateMachine(OPN_RJCT,reason);
+  if ( m_peerLinkId == 0)
+    m_peerLinkId = localLinkId;
+  m_configuration = conf;
+  StateMachine(OPN_RJCT, reason);
 }
 
-	void
+void
 WifiPeerLinkDescriptor::PeerLinkConfirmAccept(uint16_t localLinkId,uint16_t peerLinkId, uint16_t peerAid, MeshConfigurationElement  conf)
 {
-	if( m_localLinkId != peerLinkId)
-		return;
-	if( m_peerLinkId == 0)
-		m_peerLinkId = localLinkId;
-	else if ( m_peerLinkId != localLinkId )
-		return;
-	m_configuration = conf;
-	m_peerAssocId = peerAid;
-	StateMachine(CNF_ACPT);
+  if ( m_localLinkId != peerLinkId)
+    return;
+  if ( m_peerLinkId == 0)
+    m_peerLinkId = localLinkId;
+  else if ( m_peerLinkId != localLinkId )
+    return;
+  m_configuration = conf;
+  m_peerAssocId = peerAid;
+  StateMachine(CNF_ACPT);
 }
 
-void   WifiPeerLinkDescriptor:: PeerLinkConfirmReject(uint16_t localLinkId, uint16_t peerLinkId, 
-		MeshConfigurationElement  conf,dot11sReasonCode reason)
+void   WifiPeerLinkDescriptor:: PeerLinkConfirmReject(uint16_t localLinkId, uint16_t peerLinkId,
+    MeshConfigurationElement  conf,dot11sReasonCode reason)
 {
-	if( m_localLinkId != peerLinkId)
-		return;
-	if( m_peerLinkId == 0)
-		m_peerLinkId = localLinkId;
-	else if ( m_peerLinkId != localLinkId )
-		return;
-	m_configuration = conf;
-	StateMachine(CNF_RJCT,reason);
+  if (m_localLinkId != peerLinkId)
+    return;
+  if (m_peerLinkId == 0)
+    m_peerLinkId = localLinkId;
+  else if (m_peerLinkId != localLinkId)
+    return;
+  m_configuration = conf;
+  StateMachine(CNF_RJCT, reason);
 }
 
 bool
 WifiPeerLinkDescriptor::LinkIsEstab() const
-{
-	if(m_state == ESTAB)
-		return true;
-	return false;
-}
+  {
+    if (m_state == ESTAB)
+      return true;
+    return false;
+  }
 
 bool
 WifiPeerLinkDescriptor::LinkIsIdle() const
-{
-	if(m_state == IDLE)
-		return true;
-	return false;
-}
+  {
+    if (m_state == IDLE)
+      return true;
+    return false;
+  }
 
-	void
+void
 WifiPeerLinkDescriptor::StateMachine(PeerEvent event,dot11sReasonCode reasoncode)
 {
-	switch(m_state)
-	{
-		case IDLE:
-			switch(event)
-			{
-				case PASOPN:
-					m_state = LISTEN;
-					break;
-				case ACTOPN:
-					m_state = OPN_SNT;
-					SendPeerLinkOpen();
-					SetRetryTimer();
-					break;
-				default:{}
-			}
-			break;
-		case LISTEN:
-			switch(event)
-			{
-				case CNCL:
-				case CLS_ACPT:
-					m_state=IDLE;
-					// TODO Callback MLME-SignalPeerLinkStatus
-					break;
-				case REQ_RJCT:
-					SendPeerLinkClose(reasoncode);
-					break;
-				case ACTOPN:
-					m_state=OPN_SNT;
-					SendPeerLinkOpen();
-					SetRetryTimer();
-					break;
-				case OPN_ACPT:
-					m_state = OPN_RCVD;
-					SendPeerLinkConfirm();
-					SendPeerLinkOpen();
-					SetRetryTimer();
-					break;
-				default:{}
-			}
-			break;
-		case OPN_SNT:
-			switch(event)
-			{
-				case TOR1:
-					SendPeerLinkOpen();
-					m_retryCounter++;
-					SetRetryTimer();
-					break;
-				case CNF_ACPT:
-					m_state = CNF_RCVD;
-					ClearRetryTimer();
-					SetConfirmTimer();
-					break;
-				case OPN_ACPT:
-					m_state = OPN_RCVD;
-					SendPeerLinkConfirm();
-					break;
-				case CLS_ACPT:
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(REASON11S_MESH_CLOSE_RCVD);
-					SetHoldingTimer();
-					break;
-				case OPN_RJCT:
-				case CNF_RJCT:
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(reasoncode);
-					SetHoldingTimer();
-					break;
-				case TOR2:
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(REASON11S_MESH_MAX_RETRIES);
-					SetHoldingTimer();
-					break;
-				case CNCL:
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
-					SetHoldingTimer();
-					break;
-				default:{}
-			}
-			break;
-		case CNF_RCVD:
-			switch(event)
-			{
-				case CNF_ACPT:
-					break;
-				case OPN_ACPT:
-					m_state = ESTAB;
-NS_LOG_DEBUG("I am "<<m_localAddress<<", established link with "<<m_peerAddress<<", at "<<Simulator::Now());
-					ClearConfirmTimer();
-					SendPeerLinkConfirm();
-					m_linkStatusCallback(m_localAddress, m_peerAddress, true);
-					// TODO Callback MLME-SignalPeerLinkStatus
-					break;
-				case CLS_ACPT:
-					m_state = HOLDING;
-					ClearConfirmTimer();
-					SendPeerLinkClose(REASON11S_MESH_CLOSE_RCVD);
-					SetHoldingTimer();
-					break;
-				case CNF_RJCT:
-				case OPN_RJCT:
-					m_state = HOLDING;
-					ClearConfirmTimer();
-					SendPeerLinkClose(reasoncode);
-					SetHoldingTimer();
-					break;
-				case CNCL:
-					m_state = HOLDING;
-					ClearConfirmTimer();
-					SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
-					SetHoldingTimer();
-					break;
-				case TOC:
-					m_state = HOLDING;
-					SendPeerLinkClose(REASON11S_MESH_CONFIRM_TIMEOUT);
-					SetHoldingTimer();
-					break;
-				default:{}
-			}
-			break;
-		case OPN_RCVD:
-			switch(event)
-			{
-				case TOR1:
-					SendPeerLinkOpen();
-					m_retryCounter++;
-					SetRetryTimer();
-					break;
-				case CNF_ACPT:
-NS_LOG_DEBUG("I am "<<m_localAddress<<", established link with "<<m_peerAddress<<", at "<<Simulator::Now());
-					m_state = ESTAB;
-					ClearRetryTimer();
-					m_linkStatusCallback(m_localAddress, m_peerAddress, true);
-					// TODO Callback MLME-SignalPeerLinkStatus
-					break;
-				case CLS_ACPT:
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(REASON11S_MESH_CLOSE_RCVD);
-					SetHoldingTimer();
-					break;
-				case OPN_RJCT:
-				case CNF_RJCT:
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(reasoncode);
-					SetHoldingTimer();
-					break;
-				case TOR2:
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(REASON11S_MESH_MAX_RETRIES);
-					SetHoldingTimer();
-					break;
-				case CNCL:
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
-					SetHoldingTimer();
-					break;
-				default:{}
-			}
-			break;
-		case ESTAB:
-			switch(event)
-			{
+  switch (m_state)
+    {
+    case IDLE:
+      switch (event)
+        {
+        case PASOPN:
+          m_state = LISTEN;
+          break;
+        case ACTOPN:
+          m_state = OPN_SNT;
+          SendPeerLinkOpen();
+          SetRetryTimer();
+          break;
+        default:
+        {}
+        }
+      break;
+    case LISTEN:
+      switch (event)
+        {
+        case CNCL:
+        case CLS_ACPT:
+          m_state=IDLE;
+          // TODO Callback MLME-SignalPeerLinkStatus
+          break;
+        case REQ_RJCT:
+          SendPeerLinkClose(reasoncode);
+          break;
+        case ACTOPN:
+          m_state=OPN_SNT;
+          SendPeerLinkOpen();
+          SetRetryTimer();
+          break;
+        case OPN_ACPT:
+          m_state = OPN_RCVD;
+          SendPeerLinkConfirm();
+          SendPeerLinkOpen();
+          SetRetryTimer();
+          break;
+        default:
+        {}
+        }
+      break;
+    case OPN_SNT:
+      switch (event)
+        {
+        case TOR1:
+          SendPeerLinkOpen();
+          m_retryCounter++;
+          SetRetryTimer();
+          break;
+        case CNF_ACPT:
+          m_state = CNF_RCVD;
+          ClearRetryTimer();
+          SetConfirmTimer();
+          break;
+        case OPN_ACPT:
+          m_state = OPN_RCVD;
+          SendPeerLinkConfirm();
+          break;
+        case CLS_ACPT:
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(REASON11S_MESH_CLOSE_RCVD);
+          SetHoldingTimer();
+          break;
+        case OPN_RJCT:
+        case CNF_RJCT:
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(reasoncode);
+          SetHoldingTimer();
+          break;
+        case TOR2:
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(REASON11S_MESH_MAX_RETRIES);
+          SetHoldingTimer();
+          break;
+        case CNCL:
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
+          SetHoldingTimer();
+          break;
+        default:
+        {}
+        }
+      break;
+    case CNF_RCVD:
+      switch (event)
+        {
+        case CNF_ACPT:
+          break;
+        case OPN_ACPT:
+          m_state = ESTAB;
+          NS_LOG_DEBUG("I am "<<m_localAddress<<", established link with "<<m_peerAddress<<", at "<<Simulator::Now());
+          ClearConfirmTimer();
+          SendPeerLinkConfirm();
+          m_linkStatusCallback(m_localAddress, m_peerAddress, true);
+          // TODO Callback MLME-SignalPeerLinkStatus
+          break;
+        case CLS_ACPT:
+          m_state = HOLDING;
+          ClearConfirmTimer();
+          SendPeerLinkClose(REASON11S_MESH_CLOSE_RCVD);
+          SetHoldingTimer();
+          break;
+        case CNF_RJCT:
+        case OPN_RJCT:
+          m_state = HOLDING;
+          ClearConfirmTimer();
+          SendPeerLinkClose(reasoncode);
+          SetHoldingTimer();
+          break;
+        case CNCL:
+          m_state = HOLDING;
+          ClearConfirmTimer();
+          SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
+          SetHoldingTimer();
+          break;
+        case TOC:
+          m_state = HOLDING;
+          SendPeerLinkClose(REASON11S_MESH_CONFIRM_TIMEOUT);
+          SetHoldingTimer();
+          break;
+        default:
+        {}
+        }
+      break;
+    case OPN_RCVD:
+      switch (event)
+        {
+        case TOR1:
+          SendPeerLinkOpen();
+          m_retryCounter++;
+          SetRetryTimer();
+          break;
+        case CNF_ACPT:
+          NS_LOG_DEBUG("I am "<<m_localAddress<<", established link with "<<m_peerAddress<<", at "<<Simulator::Now());
+          m_state = ESTAB;
+          ClearRetryTimer();
+          m_linkStatusCallback(m_localAddress, m_peerAddress, true);
+          // TODO Callback MLME-SignalPeerLinkStatus
+          break;
+        case CLS_ACPT:
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(REASON11S_MESH_CLOSE_RCVD);
+          SetHoldingTimer();
+          break;
+        case OPN_RJCT:
+        case CNF_RJCT:
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(reasoncode);
+          SetHoldingTimer();
+          break;
+        case TOR2:
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(REASON11S_MESH_MAX_RETRIES);
+          SetHoldingTimer();
+          break;
+        case CNCL:
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
+          SetHoldingTimer();
+          break;
+        default:
+        {}
+        }
+      break;
+    case ESTAB:
+      switch (event)
+        {
 #if 0
-				case BNDSA:
-					m_state = ESTAB;
-					// TODO Callback MLME-SignalPeerLinkStatus
-					// TODO
-					break;
+        case BNDSA:
+          m_state = ESTAB;
+          // TODO Callback MLME-SignalPeerLinkStatus
+          // TODO
+          break;
 #endif
-				case OPN_ACPT:
-					SendPeerLinkConfirm();
-					break;
-				case CLS_ACPT:
-NS_LOG_DEBUG("I am "<<m_localAddress<<", CLOSED link with "<<m_peerAddress<<", at "<<Simulator::Now()<<" Close received");
-					m_state = HOLDING;
-					SendPeerLinkClose(REASON11S_MESH_CLOSE_RCVD);
-					SetHoldingTimer();
-					m_linkStatusCallback(m_localAddress, m_peerAddress, false);
-					break;
-				case OPN_RJCT:
-				case CNF_RJCT:
-NS_LOG_DEBUG("I am "<<m_localAddress<<", CLOSED link with "<<m_peerAddress<<", at "<<Simulator::Now()<<" Rejected open or confirm");
-					m_state = HOLDING;
-					ClearRetryTimer();
-					SendPeerLinkClose(reasoncode);
-					SetHoldingTimer();
-					m_linkStatusCallback(m_localAddress, m_peerAddress, false);
-					break;
-				case CNCL:
-NS_LOG_DEBUG("I am "<<m_localAddress<<", CLOSED link with "<<m_peerAddress<<", at "<<Simulator::Now()<<" Link cancelled");
-					m_state = HOLDING;
-					SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
-					SetHoldingTimer();
-					m_linkStatusCallback(m_localAddress, m_peerAddress, false);
-					break;
-				default:{}
-			}
-			break;
-		case HOLDING:
-			switch(event)
-			{
-				case CLS_ACPT:
-					ClearHoldingTimer();
-				case TOH:
-					m_state = IDLE;
-					// TODO Callback MLME-SignalPeerLinkStatus
-					break;
-				case OPN_ACPT:
-				case CNF_ACPT:
-					m_state = HOLDING;
-					// reason not spec in D2.0
-					SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
-					break;
-				case OPN_RJCT:
-				case CNF_RJCT:
-					m_state = HOLDING;
-					SendPeerLinkClose(reasoncode);
-					break;
-				default:{}
-			}
-			break;
-	}
+        case OPN_ACPT:
+          SendPeerLinkConfirm();
+          break;
+        case CLS_ACPT:
+          NS_LOG_DEBUG("I am "<<m_localAddress<<", CLOSED link with "<<m_peerAddress<<", at "<<Simulator::Now()<<" Close received");
+          m_state = HOLDING;
+          SendPeerLinkClose(REASON11S_MESH_CLOSE_RCVD);
+          SetHoldingTimer();
+          m_linkStatusCallback(m_localAddress, m_peerAddress, false);
+          break;
+        case OPN_RJCT:
+        case CNF_RJCT:
+          NS_LOG_DEBUG("I am "<<m_localAddress<<", CLOSED link with "<<m_peerAddress<<", at "<<Simulator::Now()<<" Rejected open or confirm");
+          m_state = HOLDING;
+          ClearRetryTimer();
+          SendPeerLinkClose(reasoncode);
+          SetHoldingTimer();
+          m_linkStatusCallback(m_localAddress, m_peerAddress, false);
+          break;
+        case CNCL:
+          NS_LOG_DEBUG("I am "<<m_localAddress<<", CLOSED link with "<<m_peerAddress<<", at "<<Simulator::Now()<<" Link cancelled");
+          m_state = HOLDING;
+          SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
+          SetHoldingTimer();
+          m_linkStatusCallback(m_localAddress, m_peerAddress, false);
+          break;
+        default:
+        {}
+        }
+      break;
+    case HOLDING:
+      switch (event)
+        {
+        case CLS_ACPT:
+          ClearHoldingTimer();
+        case TOH:
+          m_state = IDLE;
+          // TODO Callback MLME-SignalPeerLinkStatus
+          break;
+        case OPN_ACPT:
+        case CNF_ACPT:
+          m_state = HOLDING;
+          // reason not spec in D2.0
+          SendPeerLinkClose(REASON11S_PEER_LINK_CANCELLED);
+          break;
+        case OPN_RJCT:
+        case CNF_RJCT:
+          m_state = HOLDING;
+          SendPeerLinkClose(reasoncode);
+          break;
+        default:
+        {}
+        }
+      break;
+    }
 }
 
 void WifiPeerLinkDescriptor::ClearRetryTimer()
 {
-	m_retryTimer.Cancel(); 
+  m_retryTimer.Cancel();
 }
 
 void WifiPeerLinkDescriptor::ClearConfirmTimer()
 {
-	m_confirmTimer.Cancel(); 
+  m_confirmTimer.Cancel();
 }
 
 void WifiPeerLinkDescriptor::ClearHoldingTimer()
 {
-	m_holdingTimer.Cancel(); 
+  m_holdingTimer.Cancel();
 }
 
 void WifiPeerLinkDescriptor::SendPeerLinkClose(dot11sReasonCode reasoncode)
 {
-	PeerLinkManagementElement peerElement;
-	peerElement.SetPeerClose(m_localLinkId, m_peerLinkId, reasoncode);
-	m_mac->SendPeerLinkClose(peerElement,m_peerAddress);
+  PeerLinkManagementElement peerElement;
+  peerElement.SetPeerClose(m_localLinkId, m_peerLinkId, reasoncode);
+  m_mac->SendPeerLinkClose(peerElement,m_peerAddress);
 }
 
 void WifiPeerLinkDescriptor::SendPeerLinkOpen()
 {
-	PeerLinkManagementElement peerElement;
-	peerElement.SetPeerOpen(m_localLinkId);
-	NS_ASSERT(m_mac!=NULL);
-	m_mac->SendPeerLinkOpen(peerElement,m_peerAddress);
+  PeerLinkManagementElement peerElement;
+  peerElement.SetPeerOpen(m_localLinkId);
+  NS_ASSERT(m_mac != NULL);
+  m_mac->SendPeerLinkOpen(peerElement, m_peerAddress);
 }
 
 void WifiPeerLinkDescriptor::SendPeerLinkConfirm()
 {
-	PeerLinkManagementElement peerElement;
-	peerElement.SetPeerConfirm(m_localLinkId, m_peerLinkId);
-	m_mac->SendPeerLinkConfirm(peerElement,m_peerAddress, m_assocId);
+  PeerLinkManagementElement peerElement;
+  peerElement.SetPeerConfirm(m_localLinkId, m_peerLinkId);
+  m_mac->SendPeerLinkConfirm(peerElement, m_peerAddress, m_assocId);
 }
 
 void WifiPeerLinkDescriptor::SetHoldingTimer()
 {
-	m_holdingTimer = Simulator::Schedule(dot11sParameters::dot11MeshHoldingTimeout,&WifiPeerLinkDescriptor::HoldingTimeout,this); 
+  m_holdingTimer = Simulator::Schedule(dot11sParameters::dot11MeshHoldingTimeout, &WifiPeerLinkDescriptor::HoldingTimeout, this);
 }
 
 void WifiPeerLinkDescriptor::HoldingTimeout()
 {
-	StateMachine(TOH); 
+  StateMachine(TOH);
 }
 
 void WifiPeerLinkDescriptor::SetRetryTimer()
 {
-	m_retryTimer = Simulator::Schedule(dot11sParameters::dot11MeshRetryTimeout,&WifiPeerLinkDescriptor::RetryTimeout,this); 
+  m_retryTimer = Simulator::Schedule(dot11sParameters::dot11MeshRetryTimeout, &WifiPeerLinkDescriptor::RetryTimeout, this);
 }
 
 void WifiPeerLinkDescriptor::RetryTimeout()
 {
-	if( m_retryCounter < dot11sParameters::dot11MeshMaxRetries)
-		StateMachine(TOR1);
-	else 
-		StateMachine(TOR2);
+  if ( m_retryCounter < dot11sParameters::dot11MeshMaxRetries)
+    StateMachine(TOR1);
+  else
+    StateMachine(TOR2);
 }
 
 void WifiPeerLinkDescriptor::SetConfirmTimer()
 {
-	m_confirmTimer = Simulator::Schedule(dot11sParameters::dot11MeshConfirmTimeout,&WifiPeerLinkDescriptor::ConfirmTimeout,this); 
+  m_confirmTimer = Simulator::Schedule(dot11sParameters::dot11MeshConfirmTimeout, &WifiPeerLinkDescriptor::ConfirmTimeout, this);
 }
 
 void WifiPeerLinkDescriptor::ConfirmTimeout()
 {
-	StateMachine(TOC); 
+  StateMachine(TOC);
 }
 
 
 /***************************************************
- *	PeerManager
+ * PeerManager
  ***************************************************/
 NS_OBJECT_ENSURE_REGISTERED (WifiPeerManager);
 
-	TypeId
+TypeId
 WifiPeerManager::GetTypeId (void)
 {
-	static TypeId tid = TypeId ("ns3::WifiPeerManager")
-		.SetParent<Object> ()
-		.AddConstructor<WifiPeerManager> ()
-		//peerLinkCleanupTimeout. This constant is not specified in Draft 2.0
-		.AddAttribute ("PeerLinkCleanupPeriod",
-				"PeerLinkCleanupPeriod",
-				TimeValue (MilliSeconds (80)),
-				MakeTimeAccessor (&WifiPeerManager::m_peerLinkCleanupPeriod),
-				MakeTimeChecker ()
-			      )
-		//MaxBeaconLost. This constant is not specified in Draft 2.0
-		.AddAttribute ("MaxBeaconLost", "Max Beacon Lost",
-				UintegerValue (3),
-				MakeUintegerAccessor (&WifiPeerManager::m_maxBeaconLoss),
-				MakeUintegerChecker<uint8_t> ()
-			      )
-		//maximum number of peer links.
-		.AddAttribute ("MaxNumberOfPeerLinks",
-				"Maximum number of peer links ",
-				UintegerValue (32),
-				MakeUintegerAccessor (&WifiPeerManager::m_maxNumberOfPeerLinks),
-				MakeUintegerChecker<uint8_t> ()
-			      );
-	return tid;
+  static TypeId tid = TypeId ("ns3::WifiPeerManager")
+                      .SetParent<Object> ()
+                      .AddConstructor<WifiPeerManager> ()
+                      //peerLinkCleanupTimeout. This constant is not specified in Draft 2.0
+                      .AddAttribute ("PeerLinkCleanupPeriod",
+                                     "PeerLinkCleanupPeriod",
+                                     TimeValue (MilliSeconds (80)),
+                                     MakeTimeAccessor (&WifiPeerManager::m_peerLinkCleanupPeriod),
+                                     MakeTimeChecker ()
+                                    )
+                      //MaxBeaconLost. This constant is not specified in Draft 2.0
+                      .AddAttribute ("MaxBeaconLost", "Max Beacon Lost",
+                                     UintegerValue (3),
+                                     MakeUintegerAccessor (&WifiPeerManager::m_maxBeaconLoss),
+                                     MakeUintegerChecker<uint8_t> ()
+                                    )
+                      //maximum number of peer links.
+                      .AddAttribute ("MaxNumberOfPeerLinks",
+                                     "Maximum number of peer links ",
+                                     UintegerValue (32),
+                                     MakeUintegerAccessor (&WifiPeerManager::m_maxNumberOfPeerLinks),
+                                     MakeUintegerChecker<uint8_t> ()
+                                    );
+  return tid;
 
 }
 WifiPeerManager::WifiPeerManager()
 {
-	m_assocId = 0;
-	m_numberOfActivePeers = 0;
-	// firs peerLinkId is 1, because 0 means "unknown"
-	m_localLinkId = 1;
-	m_cleanupEvent = Simulator::Schedule (m_peerLinkCleanupPeriod, &WifiPeerManager::PeerCleanup, this);
+  m_assocId = 0;
+  m_numberOfActivePeers = 0;
+  // firs peerLinkId is 1, because 0 means "unknown"
+  m_localLinkId = 1;
+  m_cleanupEvent = Simulator::Schedule (m_peerLinkCleanupPeriod, &WifiPeerManager::PeerCleanup, this);
 }
 WifiPeerManager::~WifiPeerManager()
 {
-	m_cleanupEvent.Cancel();
-	//TODO: delete a list of descriptors
-	for(
-			PeerDescriptorsMap::iterator j = m_peerDescriptors.begin();
-			j!= m_peerDescriptors.end();
-			j++)
-	{
-		int to_delete = 0;
-		for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = j->second.begin(); i!= j->second.end(); i++)
-		{
-			to_delete ++;
-			(*i)->ClearTimingElement();
-			(*i) = 0;
-		}
-		for(int i = 0; i < to_delete; i ++)
-			j->second.pop_back();
-		j->second.clear();
-	}
-	m_peerDescriptors.clear();
-
+  m_cleanupEvent.Cancel();
+  //TODO: delete a list of descriptors
+  for (
+    PeerDescriptorsMap::iterator j = m_peerDescriptors.begin();
+    j != m_peerDescriptors.end();
+    j++)
+    {
+      int to_delete = 0;
+      for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = j->second.begin(); i!= j->second.end(); i++)
+        {
+          to_delete ++;
+          (*i)->ClearTimingElement();
+          (*i) = 0;
+        }
+      for (int i = 0; i < to_delete; i ++)
+        j->second.pop_back();
+      j->second.clear();
+    }
+  m_peerDescriptors.clear();
 }
 void
 WifiPeerManager::SetSentBeaconTimers(
-		Mac48Address portAddress, 
-		Time ReferenceTbtt,
-		Time BeaconInterval
-		)
+  Mac48Address portAddress,
+  Time ReferenceTbtt,
+  Time BeaconInterval
+)
 {
-	BeaconInfoMap::iterator myBeacon = m_myBeaconInfo.find(portAddress);
-	NS_ASSERT(myBeacon != m_myBeaconInfo.end());
-	myBeacon->second.referenceTbtt = ReferenceTbtt;
-	myBeacon->second.beaconInterval = BeaconInterval;
+  BeaconInfoMap::iterator myBeacon = m_myBeaconInfo.find(portAddress);
+  NS_ASSERT(myBeacon != m_myBeaconInfo.end());
+  myBeacon->second.referenceTbtt = ReferenceTbtt;
+  myBeacon->second.beaconInterval = BeaconInterval;
 
 }
 
 void
 WifiPeerManager::SetReceivedBeaconTimers(
-		Mac48Address portAddress, 
-		Mac48Address peerAddress,
-		Time lastBeacon,
-		Time beaconInterval,
-		WifiBeaconTimingElement beaconTiming
-		)
+  Mac48Address portAddress,
+  Mac48Address peerAddress,
+  Time lastBeacon,
+  Time beaconInterval,
+  WifiBeaconTimingElement beaconTiming
+)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!=m_peerDescriptors.end());
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-	{
-		if((*i)->GetPeerAddress() == peerAddress)
-		{
-			(*i)->SetBeaconTimingElement(beaconTiming);
-			(*i)->SetBeaconInformation(lastBeacon, beaconInterval);
-			return;
-		}
-	}
-	Ptr<WifiPeerLinkDescriptor> new_descriptor =
-		AddDescriptor(portAddress, peerAddress, Simulator::Now(), beaconInterval);
-	new_descriptor->SetBeaconTimingElement(beaconTiming);
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!=m_peerDescriptors.end());
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    {
+      if ((*i)->GetPeerAddress() == peerAddress)
+        {
+          (*i)->SetBeaconTimingElement(beaconTiming);
+          (*i)->SetBeaconInformation(lastBeacon, beaconInterval);
+          return;
+        }
+    }
+  Ptr<WifiPeerLinkDescriptor> new_descriptor =
+    AddDescriptor(portAddress, peerAddress, Simulator::Now(), beaconInterval);
+  new_descriptor->SetBeaconTimingElement(beaconTiming);
 }
 
-	bool
+bool
 WifiPeerManager::AttachPorts(std::vector<Ptr<WifiNetDevice> > ports)
 {
-	NS_ASSERT(ports.size()!=0);
-	for(std::vector<Ptr<WifiNetDevice> >::iterator i = ports.begin(); i != ports.end(); i++)
-	{
-		MeshWifiMac * meshWifiMac = dynamic_cast<MeshWifiMac *> (PeekPointer ((*i)->GetMac()));
-		if(meshWifiMac == NULL)
-			return false;
-		meshWifiMac->SetPeerLinkManager(this);
-		//Add a mac pointer:
-		m_macPointers[meshWifiMac->GetAddress()] = meshWifiMac;
-		//Add descriptor array:
-		std::vector<Ptr<WifiPeerLinkDescriptor> > descriptors;
-		m_peerDescriptors[meshWifiMac->GetAddress()] = descriptors;
-		//Add beacon timers:
-		struct BeaconInfo myBeacon;
-		m_myBeaconInfo[meshWifiMac->GetAddress()] = myBeacon;
-	}
-	return true;
+  NS_ASSERT(ports.size()!=0);
+  for (std::vector<Ptr<WifiNetDevice> >::iterator i = ports.begin(); i != ports.end(); i++)
+    {
+      MeshWifiMac * meshWifiMac = dynamic_cast<MeshWifiMac *> (PeekPointer ((*i)->GetMac()));
+      if (meshWifiMac == NULL)
+        return false;
+      meshWifiMac->SetPeerLinkManager(this);
+      //Add a mac pointer:
+      m_macPointers[meshWifiMac->GetAddress()] = meshWifiMac;
+      //Add descriptor array:
+      std::vector<Ptr<WifiPeerLinkDescriptor> > descriptors;
+      m_peerDescriptors[meshWifiMac->GetAddress()] = descriptors;
+      //Add beacon timers:
+      struct BeaconInfo myBeacon;
+      m_myBeaconInfo[meshWifiMac->GetAddress()] = myBeacon;
+    }
+  return true;
 }
-	void
+void
 WifiPeerManager::AskIfOpenNeeded(Mac48Address portAddress, Mac48Address peerAddress)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!=m_peerDescriptors.end());
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-		if((*i)->GetPeerAddress() == peerAddress)
-		{
-			if(ShouldSendOpen(portAddress, peerAddress))
-				(*i)->MLMEActivePeerLinkOpen();
-			break;
-		}
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port != m_peerDescriptors.end());
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    if ((*i)->GetPeerAddress() == peerAddress)
+      {
+        if (ShouldSendOpen(portAddress, peerAddress))
+          (*i)->MLMEActivePeerLinkOpen();
+        break;
+      }
 }
 
 void
 WifiPeerManager::SetOpenReceived(
-		Mac48Address portAddress,
-		Mac48Address peerAddress,
-		PeerLinkManagementElement peerMan,
-		MeshConfigurationElement conf
-		)
+  Mac48Address portAddress,
+  Mac48Address peerAddress,
+  PeerLinkManagementElement peerMan,
+  MeshConfigurationElement conf
+)
 {
-	dot11sReasonCode reasonCode;
-	if(!ShouldAcceptOpen(portAddress, peerAddress,reasonCode))
-		return;
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!=m_peerDescriptors.end());
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-		if((*i)->GetPeerAddress() == peerAddress)
-		{
-			(*i)->PeerLinkOpenAccept(peerMan.GetLocalLinkId(), conf);
-			return;
-		}
-	 BeaconInfoMap::iterator myBeacon =  m_myBeaconInfo.find(portAddress);
-	 NS_ASSERT(myBeacon!=m_myBeaconInfo.end());
-	Ptr<WifiPeerLinkDescriptor>new_descriptor = AddDescriptor(
-			portAddress,
-			peerAddress,
-			Simulator::Now(),
-			myBeacon->second.beaconInterval
-			);
-	new_descriptor->PeerLinkOpenAccept(peerMan.GetLocalLinkId(), conf);
+  dot11sReasonCode reasonCode;
+  if (!ShouldAcceptOpen(portAddress, peerAddress,reasonCode))
+    return;
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!=m_peerDescriptors.end());
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    if ((*i)->GetPeerAddress() == peerAddress)
+      {
+        (*i)->PeerLinkOpenAccept(peerMan.GetLocalLinkId(), conf);
+        return;
+      }
+  BeaconInfoMap::iterator myBeacon =  m_myBeaconInfo.find(portAddress);
+  NS_ASSERT(myBeacon!=m_myBeaconInfo.end());
+  Ptr<WifiPeerLinkDescriptor>new_descriptor = AddDescriptor(
+        portAddress,
+        peerAddress,
+        Simulator::Now(),
+        myBeacon->second.beaconInterval
+      );
+  new_descriptor->PeerLinkOpenAccept(peerMan.GetLocalLinkId(), conf);
 }
 void
 WifiPeerManager::SetConfirmReceived(
-		Mac48Address portAddress,
-		Mac48Address peerAddress,
-		uint16_t peerAid,
-		PeerLinkManagementElement peerMan,
-		MeshConfigurationElement meshConfig
-		)
+  Mac48Address portAddress,
+  Mac48Address peerAddress,
+  uint16_t peerAid,
+  PeerLinkManagementElement peerMan,
+  MeshConfigurationElement meshConfig
+)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!= m_peerDescriptors.end());
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-		if((*i)->GetPeerAddress() == peerAddress)
-			(*i)->PeerLinkConfirmAccept(peerMan.GetLocalLinkId(), peerMan.GetPeerLinkId(), peerAid, meshConfig);
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!= m_peerDescriptors.end());
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    if ((*i)->GetPeerAddress() == peerAddress)
+      (*i)->PeerLinkConfirmAccept(peerMan.GetLocalLinkId(), peerMan.GetPeerLinkId(), peerAid, meshConfig);
 }
 
 void
 WifiPeerManager::SetCloseReceived(
-		Mac48Address portAddress,
-		Mac48Address peerAddress,
-		PeerLinkManagementElement peerMan
-		)
+  Mac48Address portAddress,
+  Mac48Address peerAddress,
+  PeerLinkManagementElement peerMan
+)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!= m_peerDescriptors.end());
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-		if((*i)->GetPeerAddress() == peerAddress)
-		{
-			(*i)->PeerLinkClose(peerMan.GetLocalLinkId(), peerMan.GetPeerLinkId(), peerMan.GetReasonCode());
-			return;
-		}
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!= m_peerDescriptors.end());
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    if ((*i)->GetPeerAddress() == peerAddress)
+      {
+        (*i)->PeerLinkClose(peerMan.GetLocalLinkId(), peerMan.GetPeerLinkId(), peerMan.GetReasonCode());
+        return;
+      }
 }
 
 void
 WifiPeerManager::ConfigurationMismatch(
-		Mac48Address portAddress,
-		Mac48Address peerAddress
-		)
+  Mac48Address portAddress,
+  Mac48Address peerAddress
+)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!= m_peerDescriptors.end());
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-		if((*i)->GetPeerAddress() == peerAddress)
-		{
-			(*i)->MLMECancelPeerLink(REASON11S_MESH_CONFIGURATION_POLICY_VIOLATION);
-			return;
-		}
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!= m_peerDescriptors.end());
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    if ((*i)->GetPeerAddress() == peerAddress)
+      {
+        (*i)->MLMECancelPeerLink(REASON11S_MESH_CONFIGURATION_POLICY_VIOLATION);
+        return;
+      }
 
 }
 
-	WifiBeaconTimingElement
+WifiBeaconTimingElement
 WifiPeerManager::GetWifiBeaconTimingElementForMyBeacon(Mac48Address portAddress)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!= m_peerDescriptors.end());
-	WifiBeaconTimingElement return_val;
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-	{
-		//Just go through all neighbor entries and add it to timing element:
-		return_val.AddNeighboursTimingElementUnit(
-				(*i)->GetLocalAid(),
-				(*i)->GetLastBeacon(),
-				(*i)->GetBeaconInterval()
-				);
-	}
-	return return_val;
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!= m_peerDescriptors.end());
+  WifiBeaconTimingElement return_val;
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    {
+      //Just go through all neighbor entries and add it to timing element:
+      return_val.AddNeighboursTimingElementUnit(
+        (*i)->GetLocalAid(),
+        (*i)->GetLastBeacon(),
+        (*i)->GetBeaconInterval()
+      );
+    }
+  return return_val;
 
 }
-	WifiBeaconTimingElement
+WifiBeaconTimingElement
 WifiPeerManager::GetWifiBeaconTimingElementForAddress(
-		Mac48Address portAddress,
-		Mac48Address addr)
+  Mac48Address portAddress,
+  Mac48Address addr)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!= m_peerDescriptors.end());
-	WifiBeaconTimingElement return_val;
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-		if((*i)->GetPeerAddress() == addr)
-			return_val =  (*i)->GetBeaconTimingElement();
-	return return_val;
-
-
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port != m_peerDescriptors.end());
+  WifiBeaconTimingElement return_val;
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i != port->second.end(); i++)
+    if ((*i)->GetPeerAddress() == addr)
+      return_val =  (*i)->GetBeaconTimingElement();
+  return return_val;
 }
 Ptr<WifiPeerLinkDescriptor>
 WifiPeerManager::AddDescriptor(
-		Mac48Address portAddress,
-		Mac48Address peerAddress,
-		Time lastBeacon,
-		Time beaconInterval)
+  Mac48Address portAddress,
+  Mac48Address peerAddress,
+  Time lastBeacon,
+  Time beaconInterval)
 {
-	Ptr<WifiPeerLinkDescriptor> new_descriptor = Create<WifiPeerLinkDescriptor>();
-	if(m_assocId ==0xff)
-		m_assocId = 0;
-	if(m_localLinkId == 0xff)
-		m_localLinkId = 0;
-	new_descriptor->SetLocalAid(m_assocId++);
-	new_descriptor->SetLocalLinkId(m_localLinkId++);
-	new_descriptor->SetPeerAddress(peerAddress);
-	new_descriptor->SetBeaconInformation(lastBeacon, beaconInterval);
-	//DEBUG ONLY:
-	new_descriptor->SetLocalAddress(portAddress);
-	//check if port address is wrong
-	MeshMacMap::iterator pos = m_macPointers.find(portAddress);
-	NS_ASSERT(pos!= m_macPointers.end());
-	//check if descriptors array exist
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port !=m_peerDescriptors.end());
-	new_descriptor->SetMac(pos->second);
-	new_descriptor->SetMaxBeaconLoss(m_maxBeaconLoss);
-	new_descriptor->SetLinkStatusCallback(MakeCallback(&WifiPeerManager::PeerLinkStatus, this));
-	NS_ASSERT(port != m_peerDescriptors.end());
-	m_peerDescriptors[portAddress].push_back(new_descriptor);
-	return new_descriptor;
+  Ptr<WifiPeerLinkDescriptor> new_descriptor = Create<WifiPeerLinkDescriptor>();
+  if (m_assocId ==0xff)
+    m_assocId = 0;
+  if (m_localLinkId == 0xff)
+    m_localLinkId = 0;
+  new_descriptor->SetLocalAid(m_assocId++);
+  new_descriptor->SetLocalLinkId(m_localLinkId++);
+  new_descriptor->SetPeerAddress(peerAddress);
+  new_descriptor->SetBeaconInformation(lastBeacon, beaconInterval);
+  //DEBUG ONLY:
+  new_descriptor->SetLocalAddress(portAddress);
+  //check if port address is wrong
+  MeshMacMap::iterator pos = m_macPointers.find(portAddress);
+  NS_ASSERT(pos != m_macPointers.end());
+  //check if descriptors array exist
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port !=m_peerDescriptors.end());
+  new_descriptor->SetMac(pos->second);
+  new_descriptor->SetMaxBeaconLoss(m_maxBeaconLoss);
+  new_descriptor->SetLinkStatusCallback(MakeCallback(&WifiPeerManager::PeerLinkStatus, this));
+  NS_ASSERT(port != m_peerDescriptors.end());
+  m_peerDescriptors[portAddress].push_back(new_descriptor);
+  return new_descriptor;
 }
 
-	void
+void
 WifiPeerManager::PeerCleanup()
 {
-	for(
-		PeerDescriptorsMap::iterator j = m_peerDescriptors.begin();
-		j!= m_peerDescriptors.end();
-		j++)
-	{
-		std::vector<unsigned int> to_erase;
-		for(unsigned int i = 0; i< j->second.size(); i++)
-			if(j->second[i]->LinkIsIdle())
-			{
-				j->second[i]->ClearTimingElement();
-				j->second[i] = 0;
-				to_erase.push_back(i);
-			}
-		if(to_erase.size() == 0)
-			return;
-		for(unsigned int i = to_erase.size()-1 ; i >= 0; i--)
-			j->second.erase(j->second.begin() + to_erase[i]);
-		to_erase.clear();
-	}
-	m_cleanupEvent = Simulator::Schedule (m_peerLinkCleanupPeriod, &WifiPeerManager::PeerCleanup, this);
+  for (
+    PeerDescriptorsMap::iterator j = m_peerDescriptors.begin();
+    j!= m_peerDescriptors.end();
+    j++)
+    {
+      std::vector<unsigned int> to_erase;
+      for (unsigned int i = 0; i< j->second.size(); i++)
+        if (j->second[i]->LinkIsIdle())
+          {
+            j->second[i]->ClearTimingElement();
+            j->second[i] = 0;
+            to_erase.push_back(i);
+          }
+      if (to_erase.size() == 0)
+        return;
+      for (unsigned int i = to_erase.size()-1 ; i >= 0; i--)
+        j->second.erase(j->second.begin() + to_erase[i]);
+      to_erase.clear();
+    }
+  m_cleanupEvent = Simulator::Schedule (m_peerLinkCleanupPeriod, &WifiPeerManager::PeerCleanup, this);
 }
 
-	std::vector<Mac48Address>
+std::vector<Mac48Address>
 WifiPeerManager::GetNeighbourAddressList(Mac48Address portAddress, Mac48Address peerAddress)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!= m_peerDescriptors.end());
-	std::vector<Mac48Address> return_value;
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-		return_value.push_back((*i)->GetPeerAddress());
-	return return_value;
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!= m_peerDescriptors.end());
+  std::vector<Mac48Address> return_value;
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    return_value.push_back((*i)->GetPeerAddress());
+  return return_value;
 }
 
-	bool
+bool
 WifiPeerManager::IsActiveLink(Mac48Address portAddress, Mac48Address peerAddress)
 {
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!= m_peerDescriptors.end());
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-		if((*i)->GetPeerAddress() == peerAddress)
-			return ((*i)->LinkIsEstab());
-	return false;
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!= m_peerDescriptors.end());
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    if ((*i)->GetPeerAddress() == peerAddress)
+      return ((*i)->LinkIsEstab());
+  return false;
 }
 
-	bool
+bool
 WifiPeerManager::ShouldSendOpen(Mac48Address portAddress, Mac48Address peerAddress)
 {
-	if(m_numberOfActivePeers > m_maxNumberOfPeerLinks)
-		return false;
-	return true;
+  if (m_numberOfActivePeers > m_maxNumberOfPeerLinks)
+    return false;
+  return true;
 }
 
-	bool
+bool
 WifiPeerManager::ShouldAcceptOpen(Mac48Address portAddress, Mac48Address peerAddress,dot11sReasonCode & reasonCode)
 {
-	if(m_numberOfActivePeers > m_maxNumberOfPeerLinks)
-	{
-		reasonCode = REASON11S_MESH_MAX_PEERS;
-		return false;
-	}
-	return true;
+  if (m_numberOfActivePeers > m_maxNumberOfPeerLinks)
+    {
+      reasonCode = REASON11S_MESH_MAX_PEERS;
+      return false;
+    }
+  return true;
 }
 
-	Time
+Time
 WifiPeerManager::GetNextBeaconShift(
-		Mac48Address portAddress,
-		Time myNextTBTT
-		)
+  Mac48Address portAddress,
+  Time myNextTBTT
+)
 {
-	//REMINDER:: in timing element  1) last beacon reception time is measured in units of 256 microseconds
-	//                              2) beacon interval is mesured in units of 1024 microseconds
-	//                              3) hereafter TU = 1024 microseconds
-	//Im my MAC everything is stored in MicroSeconds
+  //REMINDER:: in timing element  1) last beacon reception time is measured in units of 256 microseconds
+  //                              2) beacon interval is mesured in units of 1024 microseconds
+  //                              3) hereafter TU = 1024 microseconds
+  //Im my MAC everything is stored in MicroSeconds
 
-	uint32_t myNextTBTTInTimeUnits = 0;
-	uint32_t futureBeaconInTimeUnits = 0;
-	//Going through all my timing elements and detecting future beacon collisions
-	PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
-	NS_ASSERT(port!= m_peerDescriptors.end());
-	BeaconInfoMap::iterator myBeacon = m_myBeaconInfo.find(portAddress);
-	NS_ASSERT(myBeacon!=m_myBeaconInfo.end());
-	for(std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
-	{
-		NeighboursTimingUnitsList neighbours;
-		neighbours = (*i)->GetBeaconTimingElement().GetNeighboursTimingElementsList();
-		//first let's form the list of all kown TBTTs
-		for(NeighboursTimingUnitsList::const_iterator j = neighbours.begin(); j!= neighbours.end(); j++)
-		{
-			uint16_t beaconIntervalTimeUnits;
-			beaconIntervalTimeUnits = (*j)->GetBeaconInterval();
+  uint32_t myNextTBTTInTimeUnits = 0;
+  uint32_t futureBeaconInTimeUnits = 0;
+  //Going through all my timing elements and detecting future beacon collisions
+  PeerDescriptorsMap::iterator port = m_peerDescriptors.find(portAddress);
+  NS_ASSERT(port!= m_peerDescriptors.end());
+  BeaconInfoMap::iterator myBeacon = m_myBeaconInfo.find(portAddress);
+  NS_ASSERT(myBeacon!=m_myBeaconInfo.end());
+  for (std::vector<Ptr<WifiPeerLinkDescriptor> >::iterator i = port->second.begin(); i!= port->second.end(); i++)
+    {
+      NeighboursTimingUnitsList neighbours;
+      neighbours = (*i)->GetBeaconTimingElement().GetNeighboursTimingElementsList();
+      //first let's form the list of all kown TBTTs
+      for (NeighboursTimingUnitsList::const_iterator j = neighbours.begin(); j!= neighbours.end(); j++)
+        {
+          uint16_t beaconIntervalTimeUnits;
+          beaconIntervalTimeUnits = (*j)->GetBeaconInterval();
 
-			//The last beacon time in timing elememt in Time Units
-			uint32_t lastBeaconInTimeUnits;
-			lastBeaconInTimeUnits = (*j)->GetLastBeacon()/4;
+          //The last beacon time in timing elememt in Time Units
+          uint32_t lastBeaconInTimeUnits;
+          lastBeaconInTimeUnits = (*j)->GetLastBeacon()/4;
 
-			//The time of my next beacon sending in Time Units
-			myNextTBTTInTimeUnits = myNextTBTT.GetMicroSeconds()/1024;
+          //The time of my next beacon sending in Time Units
+          myNextTBTTInTimeUnits = myNextTBTT.GetMicroSeconds()/1024;
 
-			//My beacon interval in Time Units
-			uint32_t myBeaconIntervalInTimeUnits;
-			myBeaconIntervalInTimeUnits = myBeacon->second.beaconInterval.GetMicroSeconds()/1024;
+          //My beacon interval in Time Units
+          uint32_t myBeaconIntervalInTimeUnits;
+          myBeaconIntervalInTimeUnits = myBeacon->second.beaconInterval.GetMicroSeconds()/1024;
 
-			//The time the beacon of other station will be sent
-			//we need the time just after my next TBTT (or equal to my TBTT)
-			futureBeaconInTimeUnits = lastBeaconInTimeUnits + beaconIntervalTimeUnits;
+          //The time the beacon of other station will be sent
+          //we need the time just after my next TBTT (or equal to my TBTT)
+          futureBeaconInTimeUnits = lastBeaconInTimeUnits + beaconIntervalTimeUnits;
 
-			//We apply MBAC only if beacon Intervals are equal
-			if (beaconIntervalTimeUnits == myBeaconIntervalInTimeUnits)
-			{
-				//We know when the neighbor STA transmitted it's beacon
-				//Now we need to know when it's going to send it's beacon in the future
-				//So let's use the valuse of it's beacon interval
-				while (myNextTBTTInTimeUnits >= futureBeaconInTimeUnits)
-					futureBeaconInTimeUnits = futureBeaconInTimeUnits + beaconIntervalTimeUnits;
-				//If we found that my TBTT coincide with another STA's TBTT
-				//break all cylce and return time shift for my next TBTT
-				if (myNextTBTTInTimeUnits == futureBeaconInTimeUnits)
-					break;
-			}
+          //We apply MBAC only if beacon Intervals are equal
+          if (beaconIntervalTimeUnits == myBeaconIntervalInTimeUnits)
+            {
+              //We know when the neighbor STA transmitted it's beacon
+              //Now we need to know when it's going to send it's beacon in the future
+              //So let's use the valuse of it's beacon interval
+              while (myNextTBTTInTimeUnits >= futureBeaconInTimeUnits)
+                futureBeaconInTimeUnits = futureBeaconInTimeUnits + beaconIntervalTimeUnits;
+              //If we found that my TBTT coincide with another STA's TBTT
+              //break all cylce and return time shift for my next TBTT
+              if (myNextTBTTInTimeUnits == futureBeaconInTimeUnits)
+                break;
+            }
 
-		}
-		if (myNextTBTTInTimeUnits == futureBeaconInTimeUnits)
-			break;
-	}
+        }
+      if (myNextTBTTInTimeUnits == futureBeaconInTimeUnits)
+        break;
+    }
 
-	//TBTTs coincide, so let's calculate the shift
-	if (myNextTBTTInTimeUnits == futureBeaconInTimeUnits) {
-		NS_LOG_DEBUG("MBCA: Future beacon collision is detected, applying avoidance mechanism");
-		UniformVariable randomSign(-1, 1);
-		int coefficientSign = -1;
-		if (randomSign.GetValue() >= 0)
-			coefficientSign = 1;
-		UniformVariable randomShift(1, 15);
-		//So, the shift is a random integer variable uniformly distributed in [-15;-1] U [1;15]
-		int beaconShift = randomShift.GetInteger(1,15) * coefficientSign;
-		NS_LOG_DEBUG("Shift value = " << beaconShift << " beacon TUs");
-		//We need the result not in Time Units, but in microseconds
-		return MicroSeconds(beaconShift * 1024);
-	}
-	//No collision detecterf, hence no shift is needed
-	else
-		return MicroSeconds(0);
+  //TBTTs coincide, so let's calculate the shift
+  if (myNextTBTTInTimeUnits == futureBeaconInTimeUnits)
+    {
+      NS_LOG_DEBUG("MBCA: Future beacon collision is detected, applying avoidance mechanism");
+      UniformVariable randomSign(-1, 1);
+      int coefficientSign = -1;
+      if (randomSign.GetValue() >= 0)
+        coefficientSign = 1;
+      UniformVariable randomShift(1, 15);
+      //So, the shift is a random integer variable uniformly distributed in [-15;-1] U [1;15]
+      int beaconShift = randomShift.GetInteger(1,15) * coefficientSign;
+      NS_LOG_DEBUG("Shift value = " << beaconShift << " beacon TUs");
+      //We need the result not in Time Units, but in microseconds
+      return MicroSeconds(beaconShift * 1024);
+    }
+  //No collision detecterf, hence no shift is needed
+  else
+    return MicroSeconds(0);
 }
 
 void
 WifiPeerManager::PeerLinkStatus(Mac48Address portAddress, Mac48Address peerAddress, bool status)
 {
-	MeshMacMap::iterator pos = m_macPointers.find(portAddress);
-	NS_ASSERT(pos!= m_macPointers.end());
-	pos->second->PeerLinkStatus(peerAddress, status);
+  MeshMacMap::iterator pos = m_macPointers.find(portAddress);
+  NS_ASSERT(pos!= m_macPointers.end());
+  pos->second->PeerLinkStatus(peerAddress, status);
 }
 } //namespace NS3
diff --git a/src/devices/wifi/mesh-wifi-peer-manager.h b/src/devices/wifi/mesh-wifi-peer-manager.h
index 592940ac0..46e40a7fa 100644
--- a/src/devices/wifi/mesh-wifi-peer-manager.h
+++ b/src/devices/wifi/mesh-wifi-peer-manager.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -34,299 +34,298 @@
 #include "mesh-wifi-mac.h"
 #include <list>
 
-namespace ns3
+namespace ns3 {
+class MeshWifiMac;
+/**
+ * \ingroup mesh
+ */
+class WifiPeerLinkDescriptor : public RefCountBase
 {
-	class MeshWifiMac;
-	/**
-	 * \ingroup mesh
-	 */
-	class WifiPeerLinkDescriptor : public RefCountBase
-	{
-		public:
-			WifiPeerLinkDescriptor();
-			/**
-			 * Beacon loss processing:
-			 */
-			void		SetBeaconInformation(Time lastBeacon, Time BeaconInterval);
-			void		SetMaxBeaconLoss(uint8_t maxBeaconLoss);
-			/**
-			 * \brief Methods used to detecet peer link changes
-			 * \param bool if true - opened new link, if
-			 * false - link closed
-			 */
-			void		SetLinkStatusCallback(Callback<void, Mac48Address, Mac48Address, bool> cb);
-			/**
-			 * Peer link geeters/setters
-			 */
-			void		SetPeerAddress(Mac48Address macaddr);
-			/**
-			 * Debug purpose
-			 */
-			void		SetLocalAddress(Mac48Address macaddr);
-			void		SetLocalLinkId(uint16_t id);
-			void		SetPeerLinkId(uint16_t id);
-			void		SetLocalAid(uint16_t aid);
-			void		SetPeerAid(uint16_t aid);
-			void		SetBeaconTimingElement(WifiBeaconTimingElement beaconTiming);
-			void		SetPeerLinkDescriptorElement(
-					PeerLinkManagementElement peerLinkElement
-					);
-			Mac48Address	GetPeerAddress()const;
-			/**
-			 * Debug purpose
-			 */
-			Mac48Address	GetLocalAddress()const;
-			uint16_t	GetLocalAid()const;
-			Time		GetLastBeacon()const;
-			Time		GetBeaconInterval()const;
-			WifiBeaconTimingElement
-					GetBeaconTimingElement()const;
-			PeerLinkManagementElement
-					GetPeerLinkDescriptorElement()const;
-			void		ClearTimingElement();
-			/* MLME */
-			void		MLMECancelPeerLink(dot11sReasonCode reason);
-			void		MLMEPassivePeerLinkOpen();
-			void		MLMEActivePeerLinkOpen();
-			void		MLMEPeeringRequestReject();
+public:
+  WifiPeerLinkDescriptor();
+  /**
+   * Beacon loss processing:
+   */
+  void  SetBeaconInformation(Time lastBeacon, Time BeaconInterval);
+  void  SetMaxBeaconLoss(uint8_t maxBeaconLoss);
+  /**
+   * \brief Methods used to detecet peer link changes
+   * \param bool if true - opened new link, if
+   * false - link closed
+   */
+  void  SetLinkStatusCallback(Callback<void, Mac48Address, Mac48Address, bool> cb);
+  /**
+   * Peer link geeters/setters
+   */
+  void  SetPeerAddress(Mac48Address macaddr);
+  /**
+   * Debug purpose
+   */
+  void  SetLocalAddress(Mac48Address macaddr);
+  void  SetLocalLinkId(uint16_t id);
+  void  SetPeerLinkId(uint16_t id);
+  void  SetLocalAid(uint16_t aid);
+  void  SetPeerAid(uint16_t aid);
+  void  SetBeaconTimingElement(WifiBeaconTimingElement beaconTiming);
+  void  SetPeerLinkDescriptorElement(
+    PeerLinkManagementElement peerLinkElement
+  );
+  Mac48Address GetPeerAddress()const;
+  /**
+   * Debug purpose
+   */
+  Mac48Address GetLocalAddress()const;
+  uint16_t GetLocalAid()const;
+  Time  GetLastBeacon()const;
+  Time  GetBeaconInterval()const;
+  WifiBeaconTimingElement
+  GetBeaconTimingElement()const;
+  PeerLinkManagementElement
+  GetPeerLinkDescriptorElement()const;
+  void  ClearTimingElement();
+  /* MLME */
+  void  MLMECancelPeerLink(dot11sReasonCode reason);
+  void  MLMEPassivePeerLinkOpen();
+  void  MLMEActivePeerLinkOpen();
+  void  MLMEPeeringRequestReject();
 #if 0
-			void		MLMEBindSecurityAssociation();
+  void  MLMEBindSecurityAssociation();
 #endif
-			void		SetMac(Ptr<MeshWifiMac> mac);
-			void		PeerLinkClose(uint16_t localLinkID,uint16_t peerLinkID, dot11sReasonCode reason);
-			void		PeerLinkOpenAccept(uint16_t localLinkId, MeshConfigurationElement  conf);
-			void		PeerLinkOpenReject(uint16_t localLinkId, MeshConfigurationElement  conf,dot11sReasonCode reason);
-			void		PeerLinkConfirmAccept(
-						uint16_t localLinkId,
-						uint16_t peerLinkId,
-						uint16_t peerAid,
-						MeshConfigurationElement  conf
-						);
-			void		PeerLinkConfirmReject(
-						uint16_t localLinkId,
-						uint16_t peerLinkId,
-						MeshConfigurationElement  conf,
-						dot11sReasonCode reason
-						);
-			bool		LinkIsEstab() const;
-			bool		LinkIsIdle() const;
-		private:
-			enum		PeerState {
-				IDLE,
-				LISTEN,
-				OPN_SNT,
-				CNF_RCVD,
-				OPN_RCVD,
-				ESTAB,
-				HOLDING,
-			};
-			enum		PeerEvent
-			{     
-				CNCL,		/** MLME-CancelPeerLink */
-				PASOPN,		/** MLME-PassivePeerLinkOpen */
-				ACTOPN,		/** MLME-ActivePeerLinkOpen */
-				//BNDSA,    	/** MLME-BindSecurityAssociation */
-				CLS_ACPT,	/** PeerLinkClose_Accept */
-				//CLS_IGNR,	/** PeerLinkClose_Ignore */
-				OPN_ACPT,	/** PeerLinkOpen_Accept */
-				//OPN_IGNR,	/** PeerLinkOpen_Ignore */
-				OPN_RJCT,	/** PeerLinkOpen_Reject */
-				REQ_RJCT,	/** PeerLinkOpenReject by internal reason */
-				CNF_ACPT,	/** PeerLinkConfirm_Accept */
-				//CNF_IGNR,	/** PeerLinkConfirm_Ignore */
-				CNF_RJCT,	/** PeerLinkConfirm_Reject */
-				TOR1,
-				TOR2,
-				TOC,
-				TOH,
-			};
-		private:
-			void	StateMachine(PeerEvent event,dot11sReasonCode = REASON11S_RESERVED);
-			/** Events handlers */
-			void	ClearRetryTimer();
-			void	ClearConfirmTimer();
-			void	ClearHoldingTimer();
-			void	SetHoldingTimer();
-			void	SetRetryTimer();
-			void	SetConfirmTimer();
+  void  SetMac(Ptr<MeshWifiMac> mac);
+  void  PeerLinkClose(uint16_t localLinkID,uint16_t peerLinkID, dot11sReasonCode reason);
+  void  PeerLinkOpenAccept(uint16_t localLinkId, MeshConfigurationElement  conf);
+  void  PeerLinkOpenReject(uint16_t localLinkId, MeshConfigurationElement  conf,dot11sReasonCode reason);
+  void  PeerLinkConfirmAccept(
+    uint16_t localLinkId,
+    uint16_t peerLinkId,
+    uint16_t peerAid,
+    MeshConfigurationElement  conf
+  );
+  void  PeerLinkConfirmReject(
+    uint16_t localLinkId,
+    uint16_t peerLinkId,
+    MeshConfigurationElement  conf,
+    dot11sReasonCode reason
+  );
+  bool  LinkIsEstab() const;
+  bool  LinkIsIdle() const;
+private:
+  enum  PeerState {
+    IDLE,
+    LISTEN,
+    OPN_SNT,
+    CNF_RCVD,
+    OPN_RCVD,
+    ESTAB,
+    HOLDING,
+  };
+  enum  PeerEvent
+  {
+    CNCL,  /** MLME-CancelPeerLink */
+    PASOPN,  /** MLME-PassivePeerLinkOpen */
+    ACTOPN,  /** MLME-ActivePeerLinkOpen */
+    //BNDSA,     /** MLME-BindSecurityAssociation */
+    CLS_ACPT, /** PeerLinkClose_Accept */
+    //CLS_IGNR, /** PeerLinkClose_Ignore */
+    OPN_ACPT, /** PeerLinkOpen_Accept */
+    //OPN_IGNR, /** PeerLinkOpen_Ignore */
+    OPN_RJCT, /** PeerLinkOpen_Reject */
+    REQ_RJCT, /** PeerLinkOpenReject by internal reason */
+    CNF_ACPT, /** PeerLinkConfirm_Accept */
+    //CNF_IGNR, /** PeerLinkConfirm_Ignore */
+    CNF_RJCT, /** PeerLinkConfirm_Reject */
+    TOR1,
+    TOR2,
+    TOC,
+    TOH,
+  };
+private:
+  void StateMachine(PeerEvent event,dot11sReasonCode = REASON11S_RESERVED);
+  /** Events handlers */
+  void ClearRetryTimer();
+  void ClearConfirmTimer();
+  void ClearHoldingTimer();
+  void SetHoldingTimer();
+  void SetRetryTimer();
+  void SetConfirmTimer();
 
-			void	SendPeerLinkClose(dot11sReasonCode reasoncode );
-			void	SendPeerLinkOpen();
-			void	SendPeerLinkConfirm();
-			/** Private Event */
-			void HoldingTimeout();
-			void RetryTimeout();
-			void ConfirmTimeout();
-		private:
-			Mac48Address	m_peerAddress;
-			Mac48Address	m_localAddress;
-			uint16_t	m_localLinkId;
-			uint16_t	m_peerLinkId;
-			// Used for beacon timing:
-			// All values are stored in microseconds!
-			Time		m_lastBeacon;
-			Time		m_beaconInterval;
-			uint16_t	m_assocId; //Assigned Assoc ID
-			uint16_t	m_peerAssocId; //Assoc Id assigned to me by peer
-			//State of our peer Link:
-			PeerState	m_state;
+  void SendPeerLinkClose(dot11sReasonCode reasoncode );
+  void SendPeerLinkOpen();
+  void SendPeerLinkConfirm();
+  /** Private Event */
+  void HoldingTimeout();
+  void RetryTimeout();
+  void ConfirmTimeout();
+private:
+  Mac48Address m_peerAddress;
+  Mac48Address m_localAddress;
+  uint16_t m_localLinkId;
+  uint16_t m_peerLinkId;
+  // Used for beacon timing:
+  // All values are stored in microseconds!
+  Time  m_lastBeacon;
+  Time  m_beaconInterval;
+  uint16_t m_assocId; //Assigned Assoc ID
+  uint16_t m_peerAssocId; //Assoc Id assigned to me by peer
+  //State of our peer Link:
+  PeerState m_state;
 
-			MeshConfigurationElement
-					m_configuration;
-			// State is a bitfield as defined as follows:
-			// This are states for a given 	
-			WifiBeaconTimingElement
-					m_beaconTiming;
+  MeshConfigurationElement
+  m_configuration;
+  // State is a bitfield as defined as follows:
+  // This are states for a given
+  WifiBeaconTimingElement
+  m_beaconTiming;
 
-			EventId		m_retryTimer;
-			EventId		m_holdingTimer;
-			EventId		m_confirmTimer;
-			uint16_t	m_retryCounter;
-			/**
-			 * Beacon loss timers:
-			 */
-			EventId		m_beaconLossTimer;
-			uint8_t		m_maxBeaconLoss;
-			void		BeaconLoss();
-			Ptr<MeshWifiMac> m_mac;
-			Callback<void, Mac48Address, Mac48Address, bool>
-					m_linkStatusCallback;
-	};
-	/**
-	 * \ingroup mesh
-	 */
-	class WifiPeerManager : public Object
-	{
-		public:
-			WifiPeerManager();
-			WifiPeerManager(Ptr<MeshWifiMac> mac_pointer);
-			~WifiPeerManager();
-			static	TypeId GetTypeId ();
-			//Returns a beacon timing element stored for remote station:
-			WifiBeaconTimingElement
-				GetWifiBeaconTimingElementForAddress(Mac48Address portAddress, Mac48Address addr);
-			//Returns a list of all addresses, which beacons can be decoded:
-			std::vector<Mac48Address>
-				GetNeighbourAddressList(Mac48Address portAddress, Mac48Address peerAddress);
-			bool	AttachPorts(std::vector<Ptr<WifiNetDevice> >);
-			//void	SetMac(Ptr<MeshWifiMac> mac);
-			Time	GetNextBeaconShift(Mac48Address portAddress, Time myNextTBTT);
+  EventId  m_retryTimer;
+  EventId  m_holdingTimer;
+  EventId  m_confirmTimer;
+  uint16_t m_retryCounter;
+  /**
+   * Beacon loss timers:
+   */
+  EventId  m_beaconLossTimer;
+  uint8_t  m_maxBeaconLoss;
+  void  BeaconLoss();
+  Ptr<MeshWifiMac> m_mac;
+  Callback<void, Mac48Address, Mac48Address, bool>
+  m_linkStatusCallback;
+};
+/**
+ * \ingroup mesh
+ */
+class WifiPeerManager : public Object
+{
+public:
+  WifiPeerManager();
+  WifiPeerManager(Ptr<MeshWifiMac> mac_pointer);
+  ~WifiPeerManager();
+  static TypeId GetTypeId ();
+  //Returns a beacon timing element stored for remote station:
+  WifiBeaconTimingElement
+  GetWifiBeaconTimingElementForAddress(Mac48Address portAddress, Mac48Address addr);
+  //Returns a list of all addresses, which beacons can be decoded:
+  std::vector<Mac48Address>
+  GetNeighbourAddressList(Mac48Address portAddress, Mac48Address peerAddress);
+  bool AttachPorts(std::vector<Ptr<WifiNetDevice> >);
+  //void SetMac(Ptr<MeshWifiMac> mac);
+  Time GetNextBeaconShift(Mac48Address portAddress, Time myNextTBTT);
 
-			void	SetSentBeaconTimers(
-					Mac48Address	portAddress,
-					Time		ReferenceTBTT,
-					Time		BeaconInterval
-					);
-			void	AskIfOpenNeeded(
-					Mac48Address	portAddress,
-					Mac48Address	peerAddress
-					);
-			void	SetReceivedBeaconTimers(
-					Mac48Address	portAddress,
-					Mac48Address	peerAddress,
-					Time		lastBeacon,
-					Time		beaconInterval,
-					WifiBeaconTimingElement
-					beaconTiming
-					);
-			void	SetOpenReceived(
-					Mac48Address	portAddress,
-					Mac48Address	peerAddress,
-					PeerLinkManagementElement
-					peerMan,
-					MeshConfigurationElement conf
-					);
-			void	SetConfirmReceived(
-					Mac48Address	portAddress,
-					Mac48Address	peerAddress,
-					uint16_t	peerAid,
-					PeerLinkManagementElement
-					peerMan,
-					MeshConfigurationElement meshConfig
-					);
-			void	SetCloseReceived(
-					Mac48Address	portAddress,
-					Mac48Address	peerAddress,
-					PeerLinkManagementElement peerMan
-					);
-			//Using this function MAC
-			void	ConfigurationMismatch(
-					Mac48Address	portAddress,
-					Mac48Address	peerAddress
-					);
-			//Returns a beacon timing element to added into my beacon:
-			WifiBeaconTimingElement
-				GetWifiBeaconTimingElementForMyBeacon(
-					Mac48Address	portAddress
-					);
-			bool	IsActiveLink(
-					Mac48Address	portAddress,
-					Mac48Address	peerAddress
-					);
-		private:
-			struct BeaconInfo
-			{
-				Time	referenceTbtt;	//When one of my station's beacons was put into a beacon queue;
-				Time	beaconInterval;	//Beacon interval of my station;
-			};
-      typedef std::map<Mac48Address, std::vector<Ptr<WifiPeerLinkDescriptor> >, std::less<Mac48Address> >
-        PeerDescriptorsMap;
-    	typedef std::map<Mac48Address, Ptr<MeshWifiMac>,std::less<Mac48Address> > MeshMacMap;
-			typedef std::map<Mac48Address, BeaconInfo, std::less<Mac48Address> > BeaconInfoMap;
+  void SetSentBeaconTimers(
+    Mac48Address portAddress,
+    Time  ReferenceTBTT,
+    Time  BeaconInterval
+  );
+  void AskIfOpenNeeded(
+    Mac48Address portAddress,
+    Mac48Address peerAddress
+  );
+  void SetReceivedBeaconTimers(
+    Mac48Address portAddress,
+    Mac48Address peerAddress,
+    Time  lastBeacon,
+    Time  beaconInterval,
+    WifiBeaconTimingElement
+    beaconTiming
+  );
+  void SetOpenReceived(
+    Mac48Address portAddress,
+    Mac48Address peerAddress,
+    PeerLinkManagementElement
+    peerMan,
+    MeshConfigurationElement conf
+  );
+  void SetConfirmReceived(
+    Mac48Address portAddress,
+    Mac48Address peerAddress,
+    uint16_t peerAid,
+    PeerLinkManagementElement
+    peerMan,
+    MeshConfigurationElement meshConfig
+  );
+  void SetCloseReceived(
+    Mac48Address portAddress,
+    Mac48Address peerAddress,
+    PeerLinkManagementElement peerMan
+  );
+  //Using this function MAC
+  void ConfigurationMismatch(
+    Mac48Address portAddress,
+    Mac48Address peerAddress
+  );
+  //Returns a beacon timing element to added into my beacon:
+  WifiBeaconTimingElement
+  GetWifiBeaconTimingElementForMyBeacon(
+    Mac48Address portAddress
+  );
+  bool IsActiveLink(
+    Mac48Address portAddress,
+    Mac48Address peerAddress
+  );
+private:
+  struct BeaconInfo
+  {
+    Time referenceTbtt; //When one of my station's beacons was put into a beacon queue;
+    Time beaconInterval; //Beacon interval of my station;
+  };
+  typedef std::map<Mac48Address, std::vector<Ptr<WifiPeerLinkDescriptor> >, std::less<Mac48Address> >
+  PeerDescriptorsMap;
+  typedef std::map<Mac48Address, Ptr<MeshWifiMac>,std::less<Mac48Address> > MeshMacMap;
+  typedef std::map<Mac48Address, BeaconInfo, std::less<Mac48Address> > BeaconInfoMap;
 
-			//Ptr<MeshWifiMac> m_mac;
-			//Maximum peers that may be opened:
-			uint8_t		m_maxNumberOfPeerLinks;
-			/**
-			 * Peer manager identify interface by address
-			 * of MAC. So, for every interface we store
-			 * list of peer descriptors.
-			 */
-			PeerDescriptorsMap m_peerDescriptors;
-			/**
-			 * List of MAC pointers - to iteract with each
-			 * mac
-			 */
-			MeshMacMap m_macPointers;
-			uint8_t		m_numberOfActivePeers;	//number of established peer links
-			uint16_t	m_assocId;		//last stored assoc ID
-			uint16_t	m_localLinkId;		//last stored local link ID
-			//This Variables used in beacon miss auto-cleanup:
-			//How many beacons may we lose before the link is
-			//considered to be broken:
-			uint8_t		m_maxBeaconLoss;
-			//Periodically we scan the peer manager list of peers
-			//and check if the too many  beacons were lost:
-			Time		m_peerLinkCleanupPeriod;
-			EventId		m_cleanupEvent;
-			Ptr<WifiPeerLinkDescriptor>
-				AddDescriptor(
-						Mac48Address portAddress,
-						Mac48Address peerAddress,
-						Time lastBeacon,
-						Time beaconInterval
-					     );
-			void		PeerCleanup();
-			//Mechanism of choosing PEERs:
-			bool		ShouldSendOpen(Mac48Address portAddress, Mac48Address peerAddress);
-			bool		ShouldAcceptOpen(
-						Mac48Address portAddress,
-						Mac48Address peerAddress,
-						dot11sReasonCode & reasonCode
-						);
-			//Needed for Beacon Collision Avoidance module:
-			BeaconInfoMap m_myBeaconInfo;
-			/**
-			 * Peer link Open/Close callbacks: We need to
-			 * inform MAC about this events.
-			 * \brief Interaction with peer link
-			 * descriptor - notify that peer link was
-			 * opened or closed
-			 * \param status true - peer link opened, peer
-			 * link closed otherwise
-			 */
-			void	PeerLinkStatus(Mac48Address portAddress, Mac48Address peerAddress, bool status);
-	};
+  //Ptr<MeshWifiMac> m_mac;
+  //Maximum peers that may be opened:
+  uint8_t  m_maxNumberOfPeerLinks;
+  /**
+   * Peer manager identify interface by address
+   * of MAC. So, for every interface we store
+   * list of peer descriptors.
+   */
+  PeerDescriptorsMap m_peerDescriptors;
+  /**
+   * List of MAC pointers - to iteract with each
+   * mac
+   */
+  MeshMacMap m_macPointers;
+  uint8_t  m_numberOfActivePeers; //number of established peer links
+  uint16_t m_assocId;  //last stored assoc ID
+  uint16_t m_localLinkId;  //last stored local link ID
+  //This Variables used in beacon miss auto-cleanup:
+  //How many beacons may we lose before the link is
+  //considered to be broken:
+  uint8_t  m_maxBeaconLoss;
+  //Periodically we scan the peer manager list of peers
+  //and check if the too many  beacons were lost:
+  Time  m_peerLinkCleanupPeriod;
+  EventId  m_cleanupEvent;
+  Ptr<WifiPeerLinkDescriptor>
+  AddDescriptor(
+    Mac48Address portAddress,
+    Mac48Address peerAddress,
+    Time lastBeacon,
+    Time beaconInterval
+  );
+  void  PeerCleanup();
+  //Mechanism of choosing PEERs:
+  bool  ShouldSendOpen(Mac48Address portAddress, Mac48Address peerAddress);
+  bool  ShouldAcceptOpen(
+    Mac48Address portAddress,
+    Mac48Address peerAddress,
+    dot11sReasonCode & reasonCode
+  );
+  //Needed for Beacon Collision Avoidance module:
+  BeaconInfoMap m_myBeaconInfo;
+  /**
+   * Peer link Open/Close callbacks: We need to
+   * inform MAC about this events.
+   * \brief Interaction with peer link
+   * descriptor - notify that peer link was
+   * opened or closed
+   * \param status true - peer link opened, peer
+   * link closed otherwise
+   */
+  void PeerLinkStatus(Mac48Address portAddress, Mac48Address peerAddress, bool status);
+};
 
 } //namespace ns3
 #endif
diff --git a/src/devices/wifi/mesh-wifi-perr-information-element.cc b/src/devices/wifi/mesh-wifi-perr-information-element.cc
index 962a08151..8ecdfb43b 100644
--- a/src/devices/wifi/mesh-wifi-perr-information-element.cc
+++ b/src/devices/wifi/mesh-wifi-perr-information-element.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -30,108 +30,108 @@ WifiPerrInformationElement::~WifiPerrInformationElement()
 TypeId
 WifiPerrInformationElement::GetTypeId()
 {
-	static TypeId tid = TypeId ("ns3::WifiPerrInformationElement")
-		.SetParent<Object> ();
-	return tid;
+  static TypeId tid = TypeId ("ns3::WifiPerrInformationElement")
+                      .SetParent<Object> ();
+  return tid;
 }
 void
 WifiPerrInformationElement::Print(std::ostream &os) const
-{
-	// FILL
-}
+  {
+    // FILL
+  }
 TypeId
 WifiPerrInformationElement::GetInstanceTypeId() const
-{
-	return GetTypeId();
-}
+  {
+    return GetTypeId();
+  }
 WifiPerrInformationElement::WifiPerrInformationElement():
-	m_numOfDest(0)
+    m_numOfDest(0)
 {
 }
 uint8_t
 WifiPerrInformationElement::GetNumOfDest()
 {
-	return m_numOfDest;
+  return m_numOfDest;
 }
 void
 WifiPerrInformationElement::Serialize(Buffer::Iterator i)const
-{
-	i.WriteU8 (ElementId());
-	i.WriteU8 (2+10*m_numOfDest);
-	i.WriteU8(0);
-	i.WriteU8 (m_numOfDest);
-	NS_ASSERT(m_numOfDest == m_addressUnits.size());
-	for(unsigned int j = 0; j < m_numOfDest; j++)
-	{
-		WriteTo(i,m_addressUnits[j].destination);
-		i.WriteHtonU32(m_addressUnits[j].seqnum);
-	}
-}
+  {
+    i.WriteU8 (ElementId());
+    i.WriteU8 (2+10*m_numOfDest);
+    i.WriteU8 (0);
+    i.WriteU8 (m_numOfDest);
+    NS_ASSERT (m_numOfDest == m_addressUnits.size());
+    for (unsigned int j = 0; j < m_numOfDest; j++)
+      {
+        WriteTo (i, m_addressUnits[j].destination);
+        i.WriteHtonU32 (m_addressUnits[j].seqnum);
+      }
+  }
 uint32_t
 WifiPerrInformationElement::Deserialize(Buffer::Iterator start)
 {
-	Buffer::Iterator i = start;
-	NS_ASSERT (ElementId() == i.ReadU8());
-	int length = i.ReadU8();
-	i.Next(1); //Mode flags is not used now
-	m_numOfDest = i.ReadU8();
-	NS_ASSERT((2+10*m_numOfDest) == length);
-	length = 0; //to avoid compiler warning in optimized builds
-	for(unsigned int j = 0; j < m_numOfDest; j++)
-	{
-		HwmpRtable::FailedDestination unit;
-		ReadFrom(i,unit.destination);
-		unit.seqnum = i.ReadNtohU32();
-		m_addressUnits.push_back(unit);
-	}
-	return i.GetDistanceFrom(start);
+  Buffer::Iterator i = start;
+  NS_ASSERT (ElementId() == i.ReadU8());
+  int length = i.ReadU8();
+  i.Next (1); //Mode flags is not used now
+  m_numOfDest = i.ReadU8();
+  NS_ASSERT ((2+10*m_numOfDest) == length);
+  length = 0; //to avoid compiler warning in optimized builds
+  for (unsigned int j = 0; j < m_numOfDest; j++)
+    {
+      HwmpRtable::FailedDestination unit;
+      ReadFrom(i,unit.destination);
+      unit.seqnum = i.ReadNtohU32();
+      m_addressUnits.push_back(unit);
+    }
+  return i.GetDistanceFrom(start);
 }
 
 uint32_t
 WifiPerrInformationElement::GetSerializedSize() const
-{
-	uint32_t retval = 
-		 1	//Element Id
-		 +1	//Length
-		 +1	//ModeFlags
-		 +1	//NumOfDests
-		 +6*m_numOfDest
-		 +4*m_numOfDest;
-	return retval;
-}
+  {
+    uint32_t retval =
+       1 //Element Id
+      +1 //Length
+      +1 //ModeFlags
+      +1 //NumOfDests
+      +6*m_numOfDest
+      +4*m_numOfDest;
+    return retval;
+  }
 
 void
 WifiPerrInformationElement::AddAddressUnit(HwmpRtable::FailedDestination unit)
 {
-	for(unsigned int i = 0; i < m_addressUnits.size(); i ++)
-		if(m_addressUnits[i].destination == unit.destination)
-			return;
-	m_addressUnits.push_back(unit);
-	m_numOfDest++;
+  for (unsigned int i = 0; i < m_addressUnits.size(); i ++)
+    if (m_addressUnits[i].destination == unit.destination)
+      return;
+  m_addressUnits.push_back(unit);
+  m_numOfDest++;
 }
 
 std::vector<HwmpRtable::FailedDestination>
 WifiPerrInformationElement::GetAddressUnitVector()
 {
-	return m_addressUnits;
+  return m_addressUnits;
 }
 void
 WifiPerrInformationElement::DeleteAddressUnit(Mac48Address address)
 {
-	for(std::vector<HwmpRtable::FailedDestination>::iterator i = m_addressUnits.begin(); i != m_addressUnits.end(); i ++)
-		if((*i).destination == address)
-		{
-			m_numOfDest --;
-			m_addressUnits.erase(i);
-			break;
-		}
+  for (std::vector<HwmpRtable::FailedDestination>::iterator i = m_addressUnits.begin(); i != m_addressUnits.end(); i ++)
+    if ((*i).destination == address)
+      {
+        m_numOfDest --;
+        m_addressUnits.erase(i);
+        break;
+      }
 }
 
 void
 WifiPerrInformationElement::ResetPerr()
 {
-	m_numOfDest = 0;
-	m_addressUnits.clear();
+  m_numOfDest = 0;
+  m_addressUnits.clear();
 }
 }//namespace ns3
 
diff --git a/src/devices/wifi/mesh-wifi-perr-information-element.h b/src/devices/wifi/mesh-wifi-perr-information-element.h
index f6187c2e5..731ce8060 100644
--- a/src/devices/wifi/mesh-wifi-perr-information-element.h
+++ b/src/devices/wifi/mesh-wifi-perr-information-element.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -20,49 +20,50 @@
 
 
 #ifndef PERR_INFORMATION_ELEMENT_H
-#define PERR_INFORMATION_ELEMENT_H 
+#define PERR_INFORMATION_ELEMENT_H
 
-#include	<stdint.h>
-#include	"ns3/node.h"
-#include	"ns3/buffer.h"
-#include	"ns3/mac48-address.h"
-#include	"ns3/hwmp-rtable.h"
-#include	"ns3/header.h"
-#include	"dot11s-codes.h"
+#include <stdint.h>
+#include "ns3/node.h"
+#include "ns3/buffer.h"
+#include "ns3/mac48-address.h"
+#include "ns3/hwmp-rtable.h"
+#include "ns3/header.h"
+#include "dot11s-codes.h"
 
-namespace ns3
-{
+namespace ns3 {
 /**
  * \ingroup mesh
  */
 class WifiPerrInformationElement : public Header
 {
-	public:
-		WifiPerrInformationElement();
-		~WifiPerrInformationElement();
-		static TypeId		GetTypeId();
-		virtual TypeId		GetInstanceTypeId() const;
-		virtual void		Print(std::ostream &os) const;
-		virtual void		Serialize(Buffer::Iterator i) const;
-		virtual uint32_t	Deserialize(Buffer::Iterator start);
-		virtual uint32_t	GetSerializedSize() const;
+public:
+  WifiPerrInformationElement();
+  ~WifiPerrInformationElement();
+  static  TypeId   GetTypeId();
+  virtual TypeId   GetInstanceTypeId() const;
+  virtual void     Print(std::ostream &os) const;
+  virtual void     Serialize(Buffer::Iterator i) const;
+  virtual uint32_t Deserialize(Buffer::Iterator start);
+  virtual uint32_t GetSerializedSize() const;
 #if 0
-		//RESERVED in D2.07
-		uint8_t			GetModeFlags();
-		void			SetModeFlags(uint8_t flags);
+  //RESERVED in D2.07
+  uint8_t   GetModeFlags();
+  void   SetModeFlags(uint8_t flags);
 #endif
-		uint8_t			GetNumOfDest();
+  uint8_t   GetNumOfDest();
 
-		void			AddAddressUnit(struct HwmpRtable::FailedDestination unit);
-		std::vector<HwmpRtable::FailedDestination>
-					GetAddressUnitVector();
-		void			DeleteAddressUnit(Mac48Address address);
-		void			ResetPerr();
-	private:
-		static uint8_t ElementId() { return (uint8_t)IE11S_PERR; }
-		uint8_t			m_numOfDest;
-		std::vector<HwmpRtable::FailedDestination>
-					m_addressUnits;
+  void   AddAddressUnit(struct HwmpRtable::FailedDestination unit);
+  std::vector<HwmpRtable::FailedDestination>
+  GetAddressUnitVector();
+  void   DeleteAddressUnit(Mac48Address address);
+  void   ResetPerr();
+private:
+  static uint8_t ElementId() {
+    return (uint8_t)IE11S_PERR;
+  }
+  uint8_t   m_numOfDest;
+  std::vector<HwmpRtable::FailedDestination>
+  m_addressUnits;
 };
 
 }
diff --git a/src/devices/wifi/mesh-wifi-prep-information-element.cc b/src/devices/wifi/mesh-wifi-prep-information-element.cc
index 7e06b23db..9d9352f9a 100644
--- a/src/devices/wifi/mesh-wifi-prep-information-element.cc
+++ b/src/devices/wifi/mesh-wifi-prep-information-element.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -22,7 +22,7 @@
 #include "mesh-wifi-prep-information-element.h"
 #include "ns3/address-utils.h"
 #include "ns3/assert.h"
-namespace ns3{ 
+namespace ns3 {
 /********************************
  * WifiPrepInformationElement
  *******************************/
@@ -33,184 +33,184 @@ WifiPrepInformationElement::~WifiPrepInformationElement()
 TypeId
 WifiPrepInformationElement::GetTypeId()
 {
-	static TypeId tid = TypeId ("ns3::WifiPrepInformationElement")
-		.SetParent<Object> ();
-	return tid;
+  static TypeId tid = TypeId ("ns3::WifiPrepInformationElement")
+                      .SetParent<Object> ();
+  return tid;
 }
 void
 WifiPrepInformationElement::Print(std::ostream &os) const
-{
-	//TODO:fill this method
-}
+  {
+    //TODO:fill this method
+  }
 TypeId
 WifiPrepInformationElement::GetInstanceTypeId() const
-{
-	return GetTypeId();
-}
+  {
+    return GetTypeId();
+  }
 WifiPrepInformationElement::WifiPrepInformationElement():
-	m_flags(0),
-	m_hopcount(0),
-	m_ttl(0),
-	m_destinationAddress(Mac48Address::GetBroadcast()),
-	m_destSeqNumber(0),
-	m_lifetime(0),
-	m_metric(0),
-	m_originatorAddress(Mac48Address::GetBroadcast()),
-	m_originatorSeqNumber(0)
+    m_flags(0),
+    m_hopcount(0),
+    m_ttl(0),
+    m_destinationAddress(Mac48Address::GetBroadcast()),
+    m_destSeqNumber(0),
+    m_lifetime(0),
+    m_metric(0),
+    m_originatorAddress(Mac48Address::GetBroadcast()),
+    m_originatorSeqNumber(0)
 {
 }
 void
 WifiPrepInformationElement::SetFlags(uint8_t flags)
 {
-	m_flags = flags;
+  m_flags = flags;
 }
 void
 WifiPrepInformationElement::SetHopcount(uint8_t hopcount)
 {
-	m_hopcount = hopcount;
+  m_hopcount = hopcount;
 }
 void
 WifiPrepInformationElement::SetTTL(uint8_t ttl)
 {
-	m_ttl = ttl;
+  m_ttl = ttl;
 }
 void
 WifiPrepInformationElement::SetDestinationSeqNumber(uint32_t dest_seq_number)
 {
-	m_destSeqNumber = dest_seq_number;
+  m_destSeqNumber = dest_seq_number;
 }
 void
 WifiPrepInformationElement::SetDestinationAddress(Mac48Address dest_address)
 {
-	m_destinationAddress = dest_address;
+  m_destinationAddress = dest_address;
 }
 void
 WifiPrepInformationElement::SetMetric(uint32_t metric)
 {
-	m_metric = metric;
+  m_metric = metric;
 }
-void 
+void
 WifiPrepInformationElement::SetOriginatorAddress(Mac48Address originator_address)
 {
-	m_originatorAddress = originator_address;
+  m_originatorAddress = originator_address;
 }
 void
 WifiPrepInformationElement::SetOriginatorSeqNumber(uint32_t originator_seq_number)
 {
-	m_originatorSeqNumber = originator_seq_number;
+  m_originatorSeqNumber = originator_seq_number;
 }
-void 
+void
 WifiPrepInformationElement::SetLifetime(uint32_t lifetime)
 {
-	m_lifetime = lifetime;
+  m_lifetime = lifetime;
 }
 uint8_t
 WifiPrepInformationElement::GetFlags() const
-{
-	return m_flags;
-}
+  {
+    return m_flags;
+  }
 uint8_t
-WifiPrepInformationElement::GetHopcount() const 
-{
-	return m_hopcount;
-}
+WifiPrepInformationElement::GetHopcount() const
+  {
+    return m_hopcount;
+  }
 uint32_t
 WifiPrepInformationElement::GetTTL() const
-{
-	return m_ttl;
-}
+  {
+    return m_ttl;
+  }
 uint32_t
 WifiPrepInformationElement::GetDestinationSeqNumber() const
-{
-	return m_destSeqNumber;
-}
+  {
+    return m_destSeqNumber;
+  }
 Mac48Address
 WifiPrepInformationElement::GetDestinationAddress() const
-{
-	return m_destinationAddress;
-}
-uint32_t 
+  {
+    return m_destinationAddress;
+  }
+uint32_t
 WifiPrepInformationElement::GetMetric() const
-{
-	return m_metric;
-}
+  {
+    return m_metric;
+  }
 Mac48Address
 WifiPrepInformationElement::GetOriginatorAddress() const
-{
-	return m_originatorAddress;
-}
+  {
+    return m_originatorAddress;
+  }
 uint32_t
 WifiPrepInformationElement::GetOriginatorSeqNumber() const
-{
-	return m_originatorSeqNumber;
-}
-uint32_t 
+  {
+    return m_originatorSeqNumber;
+  }
+uint32_t
 WifiPrepInformationElement::GetLifetime() const
-{
-	return m_lifetime;
-}
+  {
+    return m_lifetime;
+  }
 void
 WifiPrepInformationElement::DecrementTtl()
 {
-	m_ttl --;
+  m_ttl --;
 }
 
 void
 WifiPrepInformationElement::IncrementMetric(uint32_t metric)
 {
-	m_metric +=metric;
+  m_metric +=metric;
 }
 
 
 void
 WifiPrepInformationElement::Serialize(Buffer::Iterator i) const
-{
-	i.WriteU8 (ElementId());
-	i.WriteU8 (32);//length = 32
-	i.WriteU8 (m_flags);
-	i.WriteU8 (m_hopcount);
-	i.WriteU8 (m_ttl);
-	WriteTo(i, m_destinationAddress);
-	i.WriteHtonU32 (m_destSeqNumber);
-	i.WriteHtonU32 (m_lifetime);
-	i.WriteHtonU32 (m_metric);
-	WriteTo(i, m_originatorAddress);
-	i.WriteHtonU32 (m_originatorSeqNumber);
-}
+  {
+    i.WriteU8 (ElementId());
+    i.WriteU8 (32);//length = 32
+    i.WriteU8 (m_flags);
+    i.WriteU8 (m_hopcount);
+    i.WriteU8 (m_ttl);
+    WriteTo (i, m_destinationAddress);
+    i.WriteHtonU32 (m_destSeqNumber);
+    i.WriteHtonU32 (m_lifetime);
+    i.WriteHtonU32 (m_metric);
+    WriteTo (i, m_originatorAddress);
+    i.WriteHtonU32 (m_originatorSeqNumber);
+  }
 uint32_t
 WifiPrepInformationElement::Deserialize(Buffer::Iterator start)
 {
-	Buffer::Iterator i = start;
-	NS_ASSERT (ElementId() == i.ReadU8());
-	i.Next(1); // length is constatnt
-	m_flags = i.ReadU8();
-	m_hopcount = i.ReadU8();
-	m_ttl = i.ReadU8();
-	ReadFrom(i,m_destinationAddress);
-	m_destSeqNumber = i.ReadNtohU32();
-	m_lifetime = i.ReadNtohU32();
-	m_metric = i.ReadNtohU32();
-	ReadFrom(i,m_originatorAddress);
-	m_originatorSeqNumber = i.ReadNtohU32();
-	return i.GetDistanceFrom(start);
+  Buffer::Iterator i = start;
+  NS_ASSERT (ElementId() == i.ReadU8());
+  i.Next (1); // length is constatnt
+  m_flags = i.ReadU8();
+  m_hopcount = i.ReadU8();
+  m_ttl = i.ReadU8();
+  ReadFrom (i, m_destinationAddress);
+  m_destSeqNumber = i.ReadNtohU32();
+  m_lifetime = i.ReadNtohU32();
+  m_metric = i.ReadNtohU32();
+  ReadFrom(i, m_originatorAddress);
+  m_originatorSeqNumber = i.ReadNtohU32();
+  return i.GetDistanceFrom(start);
 }
 uint32_t
 WifiPrepInformationElement::GetSerializedSize() const
-{
-	uint32_t retval = 
-		 1	//Element ID
-		+1	//Length
-		+1	//Flags
-		+1	//Hopcount
-		+1	//TTL
-		+6	//Dest address 
-		+4	//Dest seqno
-		+4	//Lifetime
-		+4	//metric
-		+6	//Originator address
-		+4	//Originator seqno
-		+1;	//destination count
-		return retval;
+  {
+    uint32_t retval =
+       1 //Element ID
+      +1 //Length
+      +1 //Flags
+      +1 //Hopcount
+      +1 //TTL
+      +6 //Dest address
+      +4 //Dest seqno
+      +4 //Lifetime
+      +4 //metric
+      +6 //Originator address
+      +4 //Originator seqno
+      +1; //destination count
+    return retval;
 
-};
+  };
 } //namespace ns3
diff --git a/src/devices/wifi/mesh-wifi-prep-information-element.h b/src/devices/wifi/mesh-wifi-prep-information-element.h
index e49a368d5..158e2d2ea 100644
--- a/src/devices/wifi/mesh-wifi-prep-information-element.h
+++ b/src/devices/wifi/mesh-wifi-prep-information-element.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -23,61 +23,62 @@
 #define WIFI_PREP_INFORMATION_ELEMENT_H
 
 
-#include	<stdint.h>
-#include	"ns3/node.h"
-#include	"ns3/buffer.h"
-#include	"ns3/mac48-address.h"
-#include	"ns3/header.h"
-#include	"dot11s-codes.h"
-namespace ns3
-{
+#include <stdint.h>
+#include "ns3/node.h"
+#include "ns3/buffer.h"
+#include "ns3/mac48-address.h"
+#include "ns3/header.h"
+#include "dot11s-codes.h"
+namespace ns3 {
 /**
  * \ingroup mesh
  */
 class WifiPrepInformationElement : public Header
 {
-	public:
-		WifiPrepInformationElement();
-		~WifiPrepInformationElement();
-		static TypeId GetTypeId();
-		virtual TypeId GetInstanceTypeId() const;
-		virtual void Print(std::ostream &os) const;
-	        void SetFlags(uint8_t flags);
-		void SetHopcount(uint8_t hopcount);
-		void SetTTL(uint8_t ttl);
-		void SetDestinationAddress(Mac48Address dest_address);
-		void SetDestinationSeqNumber(uint32_t dest_seq_number);
-		void SetLifetime(uint32_t lifetime);
-		void SetMetric(uint32_t metric);
-		void SetOriginatorAddress(Mac48Address originator_address);
-		void SetOriginatorSeqNumber(uint32_t originator_seg_number);
-		virtual void Serialize(Buffer::Iterator i) const;
-		virtual uint32_t Deserialize(Buffer::Iterator start);
-		virtual uint32_t GetSerializedSize() const; 
+public:
+  WifiPrepInformationElement();
+  ~WifiPrepInformationElement();
+  static TypeId GetTypeId();
+  virtual TypeId GetInstanceTypeId() const;
+  virtual void Print(std::ostream &os) const;
+  void SetFlags(uint8_t flags);
+  void SetHopcount(uint8_t hopcount);
+  void SetTTL(uint8_t ttl);
+  void SetDestinationAddress(Mac48Address dest_address);
+  void SetDestinationSeqNumber(uint32_t dest_seq_number);
+  void SetLifetime(uint32_t lifetime);
+  void SetMetric(uint32_t metric);
+  void SetOriginatorAddress(Mac48Address originator_address);
+  void SetOriginatorSeqNumber(uint32_t originator_seg_number);
+  virtual void Serialize(Buffer::Iterator i) const;
+  virtual uint32_t Deserialize(Buffer::Iterator start);
+  virtual uint32_t GetSerializedSize() const;
 
-		uint8_t GetFlags() const;
-		uint8_t GetHopcount() const;
-		uint32_t GetTTL() const;
-		Mac48Address GetDestinationAddress() const;
-		uint32_t GetDestinationSeqNumber() const;
-		uint32_t GetLifetime() const;
-		uint32_t GetMetric() const;
-		Mac48Address GetOriginatorAddress() const;
-                uint32_t GetOriginatorSeqNumber()const ; 
+  uint8_t GetFlags() const;
+  uint8_t GetHopcount() const;
+  uint32_t GetTTL() const;
+  Mac48Address GetDestinationAddress() const;
+  uint32_t GetDestinationSeqNumber() const;
+  uint32_t GetLifetime() const;
+  uint32_t GetMetric() const;
+  Mac48Address GetOriginatorAddress() const;
+  uint32_t GetOriginatorSeqNumber()const ;
 
-		void		DecrementTtl();
-		void		IncrementMetric(uint32_t metric);
-	private:
-		static uint8_t ElementId() { return (uint8_t)IE11S_PREP; }
-		uint8_t		m_flags;
-		uint8_t		m_hopcount;
-		uint8_t		m_ttl;
-                Mac48Address	m_destinationAddress;
-                uint32_t	m_destSeqNumber;
-                uint32_t	m_lifetime;
-		uint32_t	m_metric;
-		Mac48Address	m_originatorAddress;
-		uint32_t	m_originatorSeqNumber;		
+  void  DecrementTtl();
+  void  IncrementMetric(uint32_t metric);
+private:
+  static uint8_t ElementId() {
+    return (uint8_t)IE11S_PREP;
+  }
+  uint8_t  m_flags;
+  uint8_t  m_hopcount;
+  uint8_t  m_ttl;
+  Mac48Address m_destinationAddress;
+  uint32_t m_destSeqNumber;
+  uint32_t m_lifetime;
+  uint32_t m_metric;
+  Mac48Address m_originatorAddress;
+  uint32_t m_originatorSeqNumber;
 };
 }//namespace ns3
 #endif
diff --git a/src/devices/wifi/mesh-wifi-preq-information-element.cc b/src/devices/wifi/mesh-wifi-preq-information-element.cc
index 8f0f4c65c..1ffc69c17 100644
--- a/src/devices/wifi/mesh-wifi-preq-information-element.cc
+++ b/src/devices/wifi/mesh-wifi-preq-information-element.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -22,61 +22,61 @@
 #include "mesh-wifi-preq-information-element.h"
 #include "ns3/address-utils.h"
 #include "ns3/assert.h"
-namespace ns3{
+namespace ns3 {
 /*************************
  * DestinationAddressUnit
  ************************/
 DestinationAddressUnit::DestinationAddressUnit()
 {
-        m_do = false;
-	m_rf = false;
-	m_destSeqNumber = 0;
-	uint8_t mac_buffer[6];
-	for (int j = 0; j < 6; j++)
-	{
-		mac_buffer[j] = 0;
-	}
-	m_destinationAddress.CopyFrom(mac_buffer);
+  m_do = false;
+  m_rf = false;
+  m_destSeqNumber = 0;
+  uint8_t mac_buffer[6];
+  for (int j = 0; j < 6; j++)
+    {
+      mac_buffer[j] = 0;
+    }
+  m_destinationAddress.CopyFrom(mac_buffer);
 }
 void
 DestinationAddressUnit::SetFlags(bool doFlag, bool rfFlag)
 {
-	m_do = doFlag;
-	m_rf = rfFlag;
+  m_do = doFlag;
+  m_rf = rfFlag;
 }
 
 void
 DestinationAddressUnit::SetDestSeqNumber(uint32_t dest_seq_number)
 {
-	m_destSeqNumber = dest_seq_number;
+  m_destSeqNumber = dest_seq_number;
 }
-void 
+void
 DestinationAddressUnit::SetDestinationAddress(Mac48Address dest_address)
 {
-	m_destinationAddress = dest_address;
+  m_destinationAddress = dest_address;
 }
 bool
 DestinationAddressUnit::IsDo()
 {
-	return m_do;
+  return m_do;
 }
 
 bool
 DestinationAddressUnit::IsRf()
 {
-	return m_rf;
+  return m_rf;
 }
 
 uint32_t
 DestinationAddressUnit::GetDestSeqNumber() const
-{
-	return m_destSeqNumber;
-}
-Mac48Address 
+  {
+    return m_destSeqNumber;
+  }
+Mac48Address
 DestinationAddressUnit::GetDestinationAddress() const
-{
-	return m_destinationAddress;
-}
+  {
+    return m_destinationAddress;
+  }
 /********************************
  * WifiPreqInformationElement
  *******************************/
@@ -87,303 +87,303 @@ WifiPreqInformationElement::~WifiPreqInformationElement()
 TypeId
 WifiPreqInformationElement::GetTypeId()
 {
-	static TypeId tid = TypeId ("ns3::WifiPreqInformationElement")
-		.SetParent<Object> ();
-	return tid;
+  static TypeId tid = TypeId ("ns3::WifiPreqInformationElement")
+                      .SetParent<Object> ();
+  return tid;
 }
 void
 WifiPreqInformationElement::Print(std::ostream &os) const
-{
-	//TODO:fill this method
-}
+  {
+    //TODO:fill this method
+  }
 
 TypeId
 WifiPreqInformationElement::GetInstanceTypeId() const
-{
-	return GetTypeId();
-}
+  {
+    return GetTypeId();
+  }
 
 WifiPreqInformationElement::WifiPreqInformationElement():
-	m_maxSize(32),
-	m_flags(0),
-	m_hopCount(0),
-	m_ttl(0),
-	m_preqId(0),
-	m_originatorAddress(Mac48Address::GetBroadcast()),
-	m_originatorSeqNumber(0),
-	m_lifetime(0),
-	m_metric(0),
-	m_destCount(0)
+    m_maxSize(32),
+    m_flags(0),
+    m_hopCount(0),
+    m_ttl(0),
+    m_preqId(0),
+    m_originatorAddress(Mac48Address::GetBroadcast()),
+    m_originatorSeqNumber(0),
+    m_lifetime(0),
+    m_metric(0),
+    m_destCount(0)
 {
 }
 void
 WifiPreqInformationElement::SetUnicastPreq()
 {
-	m_flags |= 1<<1;
+  m_flags |= 1<<1;
 }
 
 void
 WifiPreqInformationElement::SetNeedNotPrep()
 {
-	m_flags |= 1<<2;
+  m_flags |= 1<<2;
 }
 //void
 //WifiPreqInformationElement::SetFlags(uint8_t flags)
 //{
-//	m_flags = flags;
+// m_flags = flags;
 //}
 void
 WifiPreqInformationElement::SetHopcount(uint8_t hopcount)
 {
-	m_hopCount = hopcount;
+  m_hopCount = hopcount;
 }
 void
 WifiPreqInformationElement::SetTTL(uint8_t ttl)
 {
-	m_ttl = ttl;
+  m_ttl = ttl;
 }
 void
 WifiPreqInformationElement::SetPreqID(uint32_t preq_id)
 {
-	m_preqId = preq_id;
+  m_preqId = preq_id;
 }
 void
 WifiPreqInformationElement::SetMetric(uint32_t metric)
 {
-	m_metric = metric;
+  m_metric = metric;
 }
-void 
+void
 WifiPreqInformationElement::SetOriginatorAddress(Mac48Address originator_address)
 {
-	m_originatorAddress = originator_address;
+  m_originatorAddress = originator_address;
 }
 void
 WifiPreqInformationElement::SetOriginatorSeqNumber(uint32_t originator_seq_number)
 {
-	m_originatorSeqNumber = originator_seq_number;
+  m_originatorSeqNumber = originator_seq_number;
 }
-void 
+void
 WifiPreqInformationElement::SetLifetime(uint32_t lifetime)
 {
-	m_lifetime = lifetime;
+  m_lifetime = lifetime;
 }
 void
 WifiPreqInformationElement::SetDestCount(uint8_t dest_count)
 {
-	m_destCount = dest_count;
+  m_destCount = dest_count;
 }
 
 //uint8_t
 //WifiPreqInformationElement::GetFlags() const
 //{
-//	return m_flags;
+// return m_flags;
 //}
 bool
 WifiPreqInformationElement::IsUnicastPreq() const
-{
-	return (m_flags & (1<<1));
-}
+  {
+    return (m_flags & (1<<1));
+  }
 
 bool
 WifiPreqInformationElement::IsNeedNotPrep() const
-{
-	return (m_flags & (1<<2));
-}
+  {
+    return (m_flags & (1<<2));
+  }
 
 uint8_t
 WifiPreqInformationElement::GetHopCount() const
-{
-	return m_hopCount;
-}
+  {
+    return m_hopCount;
+  }
 uint8_t
 WifiPreqInformationElement::GetTtl() const
-{
-	return m_ttl;
-}
+  {
+    return m_ttl;
+  }
 uint32_t
 WifiPreqInformationElement::GetPreqID() const
-{
-	return m_preqId;
-}
-uint32_t 
+  {
+    return m_preqId;
+  }
+uint32_t
 WifiPreqInformationElement::GetMetric() const
-{
-	return m_metric;
-}
+  {
+    return m_metric;
+  }
 Mac48Address
 WifiPreqInformationElement::GetOriginatorAddress() const
-{
-	return m_originatorAddress;
-}
+  {
+    return m_originatorAddress;
+  }
 uint32_t
 WifiPreqInformationElement::GetOriginatorSeqNumber() const
-{
-	return m_originatorSeqNumber;
-}
-uint32_t 
+  {
+    return m_originatorSeqNumber;
+  }
+uint32_t
 WifiPreqInformationElement::GetLifetime() const
-{
-	return m_lifetime;
-}
+  {
+    return m_lifetime;
+  }
 
 uint8_t
 WifiPreqInformationElement::GetDestCount() const
-{
-	return m_destCount;
-}
+  {
+    return m_destCount;
+  }
 
 void
 WifiPreqInformationElement::DecrementTtl()
 {
-	m_ttl --;
-	m_hopCount ++;
+  m_ttl --;
+  m_hopCount ++;
 }
 
 void
 WifiPreqInformationElement::IncrementMetric(uint32_t metric)
 {
-	m_metric +=metric;
+  m_metric +=metric;
 }
 
 void
 WifiPreqInformationElement::Serialize(Buffer::Iterator i) const
-{
-	i.WriteU8 (ElementId());
-	//TODO:Check maxsize
-	uint8_t length = m_destCount*11+28;
-	if(m_destCount> m_maxSize)
-		length -=(m_destCount-m_maxSize)*11;
-	i.WriteU8(length);
-	i.WriteU8 (m_flags);
-	i.WriteU8 (m_hopCount);
-	i.WriteU8 (m_ttl);
-	i.WriteHtonU32 (m_preqId);
-	WriteTo(i, m_originatorAddress);
-	i.WriteHtonU32 (m_originatorSeqNumber);
-	i.WriteHtonU32 (m_lifetime);
-	i.WriteHtonU32 (m_metric);
-	i.WriteU8 (m_destCount);
-	int written = 0;
-	for (std::vector<Ptr<DestinationAddressUnit> >::const_iterator j = m_destinations.begin(); j!= m_destinations.end(); j++)
-	{
-		uint8_t flags = 0;
-		if((*j)->IsDo())
-			flags +=128;
-		if((*j)->IsRf())
-			flags +=64;
-		i.WriteU8(flags);
-		WriteTo(i,(*j)->GetDestinationAddress());
-		i.WriteHtonU32 ((*j)->GetDestSeqNumber());
-		written++;
-		if (written > m_maxSize)
-			break;
-	}
-}
+  {
+    i.WriteU8 (ElementId());
+    //TODO:Check maxsize
+    uint8_t length = m_destCount*11+28;
+    if (m_destCount> m_maxSize)
+      length -=(m_destCount-m_maxSize)*11;
+    i.WriteU8 (length);
+    i.WriteU8 (m_flags);
+    i.WriteU8 (m_hopCount);
+    i.WriteU8 (m_ttl);
+    i.WriteHtonU32 (m_preqId);
+    WriteTo (i, m_originatorAddress);
+    i.WriteHtonU32 (m_originatorSeqNumber);
+    i.WriteHtonU32 (m_lifetime);
+    i.WriteHtonU32 (m_metric);
+    i.WriteU8 (m_destCount);
+    int written = 0;
+    for (std::vector<Ptr<DestinationAddressUnit> >::const_iterator j = m_destinations.begin(); j!= m_destinations.end(); j++)
+      {
+        uint8_t flags = 0;
+        if ((*j)->IsDo())
+          flags +=128;
+        if ((*j)->IsRf())
+          flags +=64;
+        i.WriteU8 (flags);
+        WriteTo (i,(*j)->GetDestinationAddress());
+        i.WriteHtonU32 ((*j)->GetDestSeqNumber());
+        written++;
+        if (written > m_maxSize)
+          break;
+      }
+  }
 
 uint32_t
 WifiPreqInformationElement::Deserialize(Buffer::Iterator start)
 {
-	Buffer::Iterator i = start;
-	NS_ASSERT (ElementId() == i.ReadU8());
-	uint8_t length;
-	length = i.ReadU8();
-	m_flags = i.ReadU8();
-	m_hopCount = i.ReadU8();
-	m_ttl = i.ReadU8();
-	m_preqId = i.ReadNtohU32();
-	ReadFrom(i,m_originatorAddress);
-	m_originatorSeqNumber = i.ReadNtohU32();
-        m_lifetime = i.ReadNtohU32();
-	m_metric = i.ReadNtohU32();
-	m_destCount = i.ReadU8();
-	for (int j = 0; j < m_destCount; j++ )
-	{
-		Ptr<DestinationAddressUnit> new_element = Create<DestinationAddressUnit>();
-		bool doFlag = false;
-		bool rfFlag = false;
-		uint8_t flags = i.ReadU8();
-		if(flags >= 128)
-		{
-			doFlag = true;
-			flags -=128;
-		}
-		if(flags >=64)
-			rfFlag = true;
-		new_element->SetFlags(doFlag, rfFlag);
-		Mac48Address addr;
-		ReadFrom(i,addr);
-		new_element->SetDestinationAddress(addr);
-		new_element->SetDestSeqNumber(i.ReadNtohU32());
-		m_destinations.push_back(new_element);
-		NS_ASSERT(28+j*11 < length);
-	}
-	return i.GetDistanceFrom(start);
+  Buffer::Iterator i = start;
+  NS_ASSERT (ElementId() == i.ReadU8());
+  uint8_t length;
+  length = i.ReadU8 ();
+  m_flags = i.ReadU8 ();
+  m_hopCount = i.ReadU8 ();
+  m_ttl = i.ReadU8 ();
+  m_preqId = i.ReadNtohU32 ();
+  ReadFrom (i, m_originatorAddress);
+  m_originatorSeqNumber = i.ReadNtohU32();
+  m_lifetime = i.ReadNtohU32();
+  m_metric = i.ReadNtohU32();
+  m_destCount = i.ReadU8();
+  for (int j = 0; j < m_destCount; j++ )
+    {
+      Ptr<DestinationAddressUnit> new_element = Create<DestinationAddressUnit>();
+      bool doFlag = false;
+      bool rfFlag = false;
+      uint8_t flags = i.ReadU8();
+      if (flags >= 128)
+        {
+          doFlag = true;
+          flags -=128;
+        }
+      if (flags >=64)
+        rfFlag = true;
+      new_element->SetFlags(doFlag, rfFlag);
+      Mac48Address addr;
+      ReadFrom (i,addr);
+      new_element->SetDestinationAddress(addr);
+      new_element->SetDestSeqNumber(i.ReadNtohU32());
+      m_destinations.push_back(new_element);
+      NS_ASSERT(28+j*11 < length);
+    }
+  return i.GetDistanceFrom(start);
 }
 uint32_t
 WifiPreqInformationElement::GetSerializedSize() const
-{
-	uint32_t retval = 
-		 1	//Element ID
-		+1	//Length
-		+1	//Flags
-		+1	//Hopcount
-		+1	//TTL
-		+4	//PREQ ID
-		+6	//Source address (originator)
-		+4	//Originator seqno
-		+4	//Lifetime
-		+4	//metric
-		+1;	//destination count
-	if(m_destCount > m_maxSize)
-		retval+=(m_maxSize*11);
-	else
-		retval +=(m_destCount*11);
-	return retval;
-}
+  {
+    uint32_t retval =
+       1 //Element ID
+      +1 //Length
+      +1 //Flags
+      +1 //Hopcount
+      +1 //TTL
+      +4 //PREQ ID
+      +6 //Source address (originator)
+      +4 //Originator seqno
+      +4 //Lifetime
+      +4 //metric
+      +1; //destination count
+    if (m_destCount > m_maxSize)
+      retval+=(m_maxSize*11);
+    else
+      retval +=(m_destCount*11);
+    return retval;
+  }
 std::vector<Ptr<DestinationAddressUnit> >
 WifiPreqInformationElement::GetDestinationList()
 {
-	return m_destinations;
+  return m_destinations;
 }
 void
 WifiPreqInformationElement::AddDestinationAddressElement(
-		bool doFlag, bool rfFlag,
-		Mac48Address dest_address,
-                uint32_t dest_seq_number
-		)
+  bool doFlag, bool rfFlag,
+  Mac48Address dest_address,
+  uint32_t dest_seq_number
+)
 {
-	for(std::vector<Ptr<DestinationAddressUnit> >::iterator i = m_destinations.begin(); i!=m_destinations.end(); i++ )
-		if((*i)->GetDestinationAddress() == dest_address)
-			return;
-	Ptr<DestinationAddressUnit>new_element = Create<DestinationAddressUnit>();
-	new_element->SetFlags(doFlag, rfFlag);
-	new_element->SetDestinationAddress(dest_address);
-	new_element->SetDestSeqNumber(dest_seq_number);
-	m_destinations.push_back(new_element);
-	m_destCount++;
+  for (std::vector<Ptr<DestinationAddressUnit> >::iterator i = m_destinations.begin(); i!=m_destinations.end(); i++ )
+    if ((*i)->GetDestinationAddress() == dest_address)
+      return;
+  Ptr<DestinationAddressUnit>new_element = Create<DestinationAddressUnit>();
+  new_element->SetFlags(doFlag, rfFlag);
+  new_element->SetDestinationAddress(dest_address);
+  new_element->SetDestSeqNumber(dest_seq_number);
+  m_destinations.push_back(new_element);
+  m_destCount++;
 }
 
 void
 WifiPreqInformationElement::DelDestinationAddressElement(Mac48Address dest_address)
 {
-	for(std::vector<Ptr<DestinationAddressUnit> >::iterator i = m_destinations.begin(); i!=m_destinations.end(); i++ )
-	if((*i)->GetDestinationAddress() == dest_address)
-		{
-			m_destinations.erase(i);
-			m_destCount--;
-			break;
-		}
+  for (std::vector<Ptr<DestinationAddressUnit> >::iterator i = m_destinations.begin(); i!=m_destinations.end(); i++)
+    if ((*i)->GetDestinationAddress() == dest_address)
+      {
+        m_destinations.erase(i);
+        m_destCount--;
+        break;
+      }
 }
 
 void
 WifiPreqInformationElement::ClearDestinationAddressElement()
 {
-	int i;
-	for(std::vector<Ptr<DestinationAddressUnit> >::iterator j = m_destinations.begin(); j!= m_destinations.end(); j++)
-		(*j) = 0;
-	for(i = 0; i < m_destCount; i ++)
-		m_destinations.pop_back();
-	m_destinations.clear();
+  int i;
+  for (std::vector<Ptr<DestinationAddressUnit> >::iterator j = m_destinations.begin(); j!= m_destinations.end(); j++)
+    (*j) = 0;
+  for (i = 0; i < m_destCount; i ++)
+    m_destinations.pop_back();
+  m_destinations.clear();
 };
 
 }
diff --git a/src/devices/wifi/mesh-wifi-preq-information-element.h b/src/devices/wifi/mesh-wifi-preq-information-element.h
index b444fcef7..7bd3efc16 100644
--- a/src/devices/wifi/mesh-wifi-preq-information-element.h
+++ b/src/devices/wifi/mesh-wifi-preq-information-element.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -22,107 +22,107 @@
 #ifndef WIFI_PREQ_INFORMATION_ELEMENT_H
 #define WIFI_PREQ_INFORMATION_ELEMENT_H
 
-#include	<stdint.h>
-#include	"ns3/node.h"
-#include	"ns3/buffer.h"
-#include	"ns3/mac48-address.h"
-#include	"ns3/header.h"
-#include	<vector>
-#include 	"dot11s-codes.h"
-namespace ns3
-{
+#include <stdint.h>
+#include "ns3/node.h"
+#include "ns3/buffer.h"
+#include "ns3/mac48-address.h"
+#include "ns3/header.h"
+#include <vector>
+#include  "dot11s-codes.h"
+namespace ns3 {
 /**
  * \ingroup mesh
  */
 class DestinationAddressUnit : public RefCountBase
 {
-	public:
-		DestinationAddressUnit();
-		void	SetFlags(bool doFlag, bool rfflag);
-		//void SetPerDestFlags(uint8_t per_dest_flags);
-		void SetDestinationAddress(Mac48Address dest_address);
-		void SetDestSeqNumber(uint32_t dest_seq_number);
-		bool IsDo();
-		bool IsRf();
-		Mac48Address GetDestinationAddress() const;
-		uint32_t GetDestSeqNumber() const;
+public:
+  DestinationAddressUnit();
+  void SetFlags(bool doFlag, bool rfflag);
+  //void SetPerDestFlags(uint8_t per_dest_flags);
+  void SetDestinationAddress(Mac48Address dest_address);
+  void SetDestSeqNumber(uint32_t dest_seq_number);
+  bool IsDo();
+  bool IsRf();
+  Mac48Address GetDestinationAddress() const;
+  uint32_t GetDestSeqNumber() const;
 
-	private:
-		bool m_do;
-		bool m_rf;
-		Mac48Address m_destinationAddress;
-		uint32_t m_destSeqNumber;
-};	
+private:
+  bool m_do;
+  bool m_rf;
+  Mac48Address m_destinationAddress;
+  uint32_t m_destSeqNumber;
+};
 /**
  * \ingroup mesh
  */
 class WifiPreqInformationElement : public Header
 {
-	public:
-		WifiPreqInformationElement();
-		~WifiPreqInformationElement ();
-		static TypeId GetTypeId ();
-		virtual TypeId GetInstanceTypeId() const;
-		virtual void Print(std::ostream &os) const;
-		void AddDestinationAddressElement(
-			bool doFlag,
-			bool rfFlag,
-			Mac48Address dest_address,
-			uint32_t dest_seq_number
-		 	);
-                void DelDestinationAddressElement(Mac48Address dest_address);
-		void ClearDestinationAddressElement();
-                std::vector<Ptr<DestinationAddressUnit> > GetDestinationList ();
-		//void SetFlags(uint8_t flags);
-		void SetUnicastPreq();
-		/*
-		 * \brief In proactive case: need we send PREP
-		 */
-		void SetNeedNotPrep();
-		void SetHopcount(uint8_t hopcount);
-		void SetTTL(uint8_t ttl);
-		void SetPreqID(uint32_t id);
-		void SetOriginatorAddress(Mac48Address originator_address);
-		void SetOriginatorSeqNumber(uint32_t originator_seq_number);
-		void SetLifetime(uint32_t lifetime);
-		void SetMetric(uint32_t metric);
-		void SetDestCount(uint8_t dest_count);
+public:
+  WifiPreqInformationElement();
+  ~WifiPreqInformationElement ();
+  static TypeId GetTypeId ();
+  virtual TypeId GetInstanceTypeId() const;
+  virtual void Print(std::ostream &os) const;
+  void AddDestinationAddressElement(
+    bool doFlag,
+    bool rfFlag,
+    Mac48Address dest_address,
+    uint32_t dest_seq_number
+  );
+  void DelDestinationAddressElement(Mac48Address dest_address);
+  void ClearDestinationAddressElement();
+  std::vector<Ptr<DestinationAddressUnit> > GetDestinationList ();
+  //void SetFlags(uint8_t flags);
+  void SetUnicastPreq();
+  /*
+   * \brief In proactive case: need we send PREP
+   */
+  void SetNeedNotPrep();
+  void SetHopcount(uint8_t hopcount);
+  void SetTTL(uint8_t ttl);
+  void SetPreqID(uint32_t id);
+  void SetOriginatorAddress(Mac48Address originator_address);
+  void SetOriginatorSeqNumber(uint32_t originator_seq_number);
+  void SetLifetime(uint32_t lifetime);
+  void SetMetric(uint32_t metric);
+  void SetDestCount(uint8_t dest_count);
 
-                virtual void Serialize(Buffer::Iterator i) const;
-		virtual uint32_t Deserialize(Buffer::Iterator i);
-		virtual uint32_t GetSerializedSize() const;
+  virtual void Serialize(Buffer::Iterator i) const;
+  virtual uint32_t Deserialize(Buffer::Iterator i);
+  virtual uint32_t GetSerializedSize() const;
 
-		//uint8_t		GetFlags() const ;
-		bool		IsUnicastPreq() const;
-		bool		IsNeedNotPrep() const;
-		uint8_t 	GetHopCount() const;
-		uint8_t		GetTtl()const ;
-		uint32_t	GetPreqID() const;
-		Mac48Address	GetOriginatorAddress() const;
-		uint32_t	GetOriginatorSeqNumber() const;
-		uint32_t	GetLifetime() const;
-		uint32_t	GetMetric() const;
-		uint8_t		GetDestCount() const;
-		void		DecrementTtl();
-		void		IncrementMetric(uint32_t metric);
-
-	private:
-		static uint8_t ElementId() { return (uint8_t)IE11S_PREQ; }
-		//how many destinations we support
-		uint8_t	m_maxSize; //TODO: make as an attrubute
-		//Fields:
-		uint8_t	m_flags;
-		uint8_t	m_hopCount;
-		uint8_t	m_ttl;
-		uint32_t	m_preqId;
-		Mac48Address	m_originatorAddress;
-		uint32_t	m_originatorSeqNumber;
-		uint32_t	m_lifetime;
-		uint32_t	m_metric;
-		uint8_t		m_destCount;
-		std::vector<Ptr<DestinationAddressUnit> >
-				m_destinations;
+  //uint8_t  GetFlags() const ;
+  bool  IsUnicastPreq() const;
+  bool  IsNeedNotPrep() const;
+  uint8_t  GetHopCount() const;
+  uint8_t  GetTtl()const ;
+  uint32_t GetPreqID() const;
+  Mac48Address GetOriginatorAddress() const;
+  uint32_t GetOriginatorSeqNumber() const;
+  uint32_t GetLifetime() const;
+  uint32_t GetMetric() const;
+  uint8_t  GetDestCount() const;
+  void  DecrementTtl();
+  void  IncrementMetric(uint32_t metric);
 
+private:
+  static uint8_t ElementId() {
+    return (uint8_t)IE11S_PREQ;
+  }
+  //how many destinations we support
+  uint8_t m_maxSize; //TODO: make as an attrubute
+  //Fields:
+  uint8_t m_flags;
+  uint8_t m_hopCount;
+  uint8_t m_ttl;
+  uint32_t m_preqId;
+  Mac48Address m_originatorAddress;
+  uint32_t m_originatorSeqNumber;
+  uint32_t m_lifetime;
+  uint32_t m_metric;
+  uint8_t  m_destCount;
+  std::vector<Ptr<DestinationAddressUnit> >
+  m_destinations;
 };
 
 } //namespace ns3
diff --git a/src/devices/wifi/mesh-wifi-rann-information-element.cc b/src/devices/wifi/mesh-wifi-rann-information-element.cc
index d9c5a9468..a3d25cfd0 100644
--- a/src/devices/wifi/mesh-wifi-rann-information-element.cc
+++ b/src/devices/wifi/mesh-wifi-rann-information-element.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -23,7 +23,7 @@
 #include "ns3/assert.h"
 #include "ns3/address-utils.h"
 
-namespace ns3{
+namespace ns3 {
 
 WifiRannInformationElement::~WifiRannInformationElement()
 {
@@ -31,129 +31,129 @@ WifiRannInformationElement::~WifiRannInformationElement()
 TypeId
 WifiRannInformationElement::GetTypeId()
 {
-	static TypeId tid = TypeId ("ns3::WifiRannInformationElement").SetParent<Object> ();
-	return tid;
+  static TypeId tid = TypeId ("ns3::WifiRannInformationElement").SetParent<Object> ();
+  return tid;
 }
 TypeId
 WifiRannInformationElement::GetInstanceTypeId() const
-{
-	return GetTypeId();
-}
+  {
+    return GetTypeId();
+  }
 void
 WifiRannInformationElement::Print(std::ostream &os)const
-{
-	// FILL
-}
+  {
+    // FILL
+  }
 WifiRannInformationElement::WifiRannInformationElement():
-	m_flags(0),
-	m_hopcount(0),
-	m_ttl(0),
-	m_originatorAddress(Mac48Address::GetBroadcast()),
-	m_destSeqNumber(0),
-	m_metric(0)
+    m_flags(0),
+    m_hopcount(0),
+    m_ttl(0),
+    m_originatorAddress(Mac48Address::GetBroadcast()),
+    m_destSeqNumber(0),
+    m_metric(0)
 {
 }
 void
 WifiRannInformationElement::SetFlags(uint8_t flags)
 {
-	m_flags = flags;
+  m_flags = flags;
 }
 void
 WifiRannInformationElement::SetHopcount(uint8_t hopcount)
 {
-	m_hopcount = hopcount;
+  m_hopcount = hopcount;
 }
 void
 WifiRannInformationElement::SetTTL(uint8_t ttl)
 {
-	m_ttl = ttl;
+  m_ttl = ttl;
 }
 void
 WifiRannInformationElement::SetDestSeqNumber(uint32_t dest_seq_number)
 {
-	m_destSeqNumber = dest_seq_number;
+  m_destSeqNumber = dest_seq_number;
 }
 void
 WifiRannInformationElement::SetMetric(uint32_t metric)
 {
-	m_metric = metric;
+  m_metric = metric;
 }
-void 
+void
 WifiRannInformationElement::SetOriginatorAddress(Mac48Address originator_address)
 {
-	m_originatorAddress = originator_address;
+  m_originatorAddress = originator_address;
 }
 
 uint8_t
 WifiRannInformationElement::GetFlags()
 {
-	return m_flags;
+  return m_flags;
 }
 uint8_t
 WifiRannInformationElement::GetHopcount()
 {
-	return m_hopcount;
+  return m_hopcount;
 }
 uint8_t
 WifiRannInformationElement::GetTTL()
 {
-	return m_ttl;
+  return m_ttl;
 }
 uint32_t
 WifiRannInformationElement::GetDestSeqNumber()
 {
-	return m_destSeqNumber;
+  return m_destSeqNumber;
 }
-uint32_t 
+uint32_t
 WifiRannInformationElement::GetMetric()
 {
-	return m_metric;
+  return m_metric;
 }
 Mac48Address
 WifiRannInformationElement::GetOriginatorAddress()
 {
-	return m_originatorAddress;
+  return m_originatorAddress;
 }
 void
 WifiRannInformationElement::Serialize(Buffer::Iterator i) const
-{
-	i.WriteU8 (ElementId());
-	i.WriteU8 (21);//length = 21
-	i.WriteU8 (m_flags);
-	i.WriteU8 (m_hopcount);
-	i.WriteU8 (m_ttl);
-	WriteTo(i, m_originatorAddress);
-	i.WriteHtonU32 (m_destSeqNumber);
-	i.WriteHtonU32 (m_metric);
-}
+  {
+    i.WriteU8 (ElementId());
+    i.WriteU8 (21);//length = 21
+    i.WriteU8 (m_flags);
+    i.WriteU8 (m_hopcount);
+    i.WriteU8 (m_ttl);
+    WriteTo (i, m_originatorAddress);
+    i.WriteHtonU32 (m_destSeqNumber);
+    i.WriteHtonU32 (m_metric);
+  }
 uint32_t
 WifiRannInformationElement::Deserialize(Buffer::Iterator start)
 {
-	Buffer::Iterator i = start;
-	NS_ASSERT (ElementId() == i.ReadU8());
-        i.Next(1);// length is constant
-	m_flags = i.ReadU8();
-	m_hopcount = i.ReadU8();
-	m_ttl = i.ReadU8();
-	ReadFrom(i, m_originatorAddress);
-	m_destSeqNumber = i.ReadNtohU32();
-	m_metric = i.ReadNtohU32();
-	return i.GetDistanceFrom(start);
+  Buffer::Iterator i = start;
+  NS_ASSERT (ElementId() == i.ReadU8());
+  i.Next (1);// length is constant
+  m_flags = i.ReadU8();
+  m_hopcount = i.ReadU8();
+  m_ttl = i.ReadU8();
+  ReadFrom(i, m_originatorAddress);
+  m_destSeqNumber = i.ReadNtohU32();
+  m_metric = i.ReadNtohU32();
+  return i.GetDistanceFrom(start);
 }
 uint32_t
 WifiRannInformationElement::GetSerializedSize() const
-{
-	uint32_t retval = 
-		 1//ElementId
-		+1//Length
-		+1//Flags
-		+1//Hopcount
-		+1//TTL
-		+6//OriginatorAddress
-		+4//DestSeqNumber
-		+4;//Metric
-	return retval;
-};
+  {
+    uint32_t retval =
+       1//ElementId
+      +1//Length
+      +1//Flags
+      +1//Hopcount
+      +1//TTL
+      +6//OriginatorAddress
+      +4//DestSeqNumber
+      +4;//Metric
+    return retval;
+  };
 
 }
 
diff --git a/src/devices/wifi/mesh-wifi-rann-information-element.h b/src/devices/wifi/mesh-wifi-rann-information-element.h
index a73c244e9..71b555adc 100644
--- a/src/devices/wifi/mesh-wifi-rann-information-element.h
+++ b/src/devices/wifi/mesh-wifi-rann-information-element.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -23,53 +23,54 @@
 #define RANN_INFORMATION_ELEMENT_H
 
 
-#include	<stdint.h>
-#include	"ns3/buffer.h"
-#include	"ns3/mac48-address.h"
-#include	"ns3/node.h"
-#include	"ns3/header.h"
-#include	"dot11s-codes.h"
+#include <stdint.h>
+#include "ns3/buffer.h"
+#include "ns3/mac48-address.h"
+#include "ns3/node.h"
+#include "ns3/header.h"
+#include "dot11s-codes.h"
 
-namespace ns3
-{
+namespace ns3 {
 /**
  * \ingroup mesh
  */
 class WifiRannInformationElement
 {
-	public:
-		WifiRannInformationElement();
-		virtual ~WifiRannInformationElement();
-		static TypeId GetTypeId();
-		virtual TypeId GetInstanceTypeId() const;
-		virtual void Print(std::ostream &os) const;
-		void SetFlags(uint8_t flags);
-		void SetHopcount(uint8_t hopcount);
-		void SetTTL(uint8_t ttl);
-		void SetOriginatorAddress(Mac48Address originator_address);
-		void SetDestSeqNumber(uint32_t dest_seq_number);
-		void SetMetric(uint32_t metric);
-		virtual void Serialize(Buffer::Iterator i) const;
-		virtual uint32_t Deserialize(Buffer::Iterator start);
-	        virtual uint32_t GetSerializedSize() const;
-		uint8_t GetFlags();
-		uint8_t GetHopcount();
-		uint8_t GetTTL();
-		Mac48Address GetOriginatorAddress();
-		uint32_t GetDestSeqNumber();
-		uint32_t GetMetric();
+public:
+  WifiRannInformationElement();
+  virtual ~WifiRannInformationElement();
+  static TypeId GetTypeId();
+  virtual TypeId GetInstanceTypeId() const;
+  virtual void Print(std::ostream &os) const;
+  void SetFlags(uint8_t flags);
+  void SetHopcount(uint8_t hopcount);
+  void SetTTL(uint8_t ttl);
+  void SetOriginatorAddress(Mac48Address originator_address);
+  void SetDestSeqNumber(uint32_t dest_seq_number);
+  void SetMetric(uint32_t metric);
+  virtual void Serialize(Buffer::Iterator i) const;
+  virtual uint32_t Deserialize(Buffer::Iterator start);
+  virtual uint32_t GetSerializedSize() const;
+  uint8_t GetFlags();
+  uint8_t GetHopcount();
+  uint8_t GetTTL();
+  Mac48Address GetOriginatorAddress();
+  uint32_t GetDestSeqNumber();
+  uint32_t GetMetric();
 
-		void DecrementTtl();
-		void IncrementMetric(uint32_t metric);
+  void DecrementTtl();
+  void IncrementMetric(uint32_t metric);
 
-	private:
-		static uint8_t ElementId() { return (uint8_t)IE11S_RANN; }
-		uint8_t m_flags;
-		uint8_t m_hopcount;
-		uint8_t m_ttl;
-		Mac48Address m_originatorAddress;
-		uint32_t m_destSeqNumber;
-		uint32_t m_metric; 
+private:
+  static uint8_t ElementId() {
+    return (uint8_t)IE11S_RANN;
+  }
+  uint8_t m_flags;
+  uint8_t m_hopcount;
+  uint8_t m_ttl;
+  Mac48Address m_originatorAddress;
+  uint32_t m_destSeqNumber;
+  uint32_t m_metric;
 };
 
 }
diff --git a/src/devices/wifi/tx-statistics.cc b/src/devices/wifi/tx-statistics.cc
index 6393c806c..f9e57c885 100644
--- a/src/devices/wifi/tx-statistics.cc
+++ b/src/devices/wifi/tx-statistics.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -30,14 +30,14 @@ namespace ns3 {
 TypeId
 WifiTxStatistics::GetTypeId(void)
 {
-	static TypeId tid = TypeId("ns3::WifiTxStatistics")
-		.SetParent<Object> ()
-		.AddConstructor<WifiTxStatistics> ();
-	return tid;
+  static TypeId tid = TypeId("ns3::WifiTxStatistics")
+                      .SetParent<Object> ()
+                      .AddConstructor<WifiTxStatistics> ();
+  return tid;
 }
 WifiTxStatistics::WifiTxStatistics():
-	m_numOfGroups(10),
-	m_maxLength(2500)
+    m_numOfGroups(10),
+    m_maxLength(2500)
 {
 }
 WifiTxStatistics::~WifiTxStatistics()
@@ -46,100 +46,99 @@ WifiTxStatistics::~WifiTxStatistics()
 void
 WifiTxStatistics::SetLengthDivisionParams(uint16_t maxLength, uint8_t numOfGroups)
 {
-	
+
 }
 void
 WifiTxStatistics::NotifyDataSent(uint16_t length, uint32_t dataRate)
 {
-	m_currentSize = length;
-	m_currentRate = dataRate;
+  m_currentSize = length;
+  m_currentRate = dataRate;
 }
 
 WifiTxStatistics::RATE_STAT::iterator
 WifiTxStatistics::FillCurrentStatPosition(uint16_t length, uint32_t dataRate)
 {
-	uint16_t group = (length/(m_maxLength/m_numOfGroups)+1)* (m_maxLength/m_numOfGroups);
+  uint16_t group = (length/(m_maxLength/m_numOfGroups)+1)* (m_maxLength/m_numOfGroups);
 #if 0
-	for(RATE_LENGTH_STAT::iterator i = m_stats.begin(); i != m_stats.end(); i ++)
-		if(i->first == )
+  for (RATE_LENGTH_STAT::iterator i = m_stats.begin(); i != m_stats.end(); i ++)
+    if (i->first == )
 #endif
-	RATE_LENGTH_STAT::iterator lengthPos = m_stats.find(group);
-	if(lengthPos == m_stats.end())
-	{
-		RATE_STAT newStat;
-		m_stats[group] = newStat;
-	}
-	lengthPos = m_stats.find(group);
-	NS_ASSERT(lengthPos != m_stats.end());
-	RATE_STAT::iterator ratePos = lengthPos->second.find(dataRate);
-	if(ratePos == lengthPos->second.end())
-	{
-		SIMPLE_STAT newStat;
-		newStat.packetsFailed =0;
-		newStat.packetsRetried = 0;
-		newStat.packetsAcked = 0;
-		newStat.rtsFailed = 0;
-		newStat.rtsRetried = 0;
-		newStat.rtsAcked = 0;
-		newStat.bytesFailed = 0;
-		newStat.bytesRetried = 0;
-		newStat.bytesAcked = 0;
-		lengthPos->second[dataRate] = newStat;
-	}
-	ratePos = lengthPos->second.find(dataRate);
-	NS_ASSERT(ratePos != lengthPos->second.end());
-	return  ratePos;
+      RATE_LENGTH_STAT::iterator lengthPos = m_stats.find(group);
+  if (lengthPos == m_stats.end())
+    {
+      RATE_STAT newStat;
+      m_stats[group] = newStat;
+    }
+  lengthPos = m_stats.find(group);
+  NS_ASSERT(lengthPos != m_stats.end());
+  RATE_STAT::iterator ratePos = lengthPos->second.find(dataRate);
+  if (ratePos == lengthPos->second.end())
+    {
+      SIMPLE_STAT newStat;
+      newStat.packetsFailed =0;
+      newStat.packetsRetried = 0;
+      newStat.packetsAcked = 0;
+      newStat.rtsFailed = 0;
+      newStat.rtsRetried = 0;
+      newStat.rtsAcked = 0;
+      newStat.bytesFailed = 0;
+      newStat.bytesRetried = 0;
+      newStat.bytesAcked = 0;
+      lengthPos->second[dataRate] = newStat;
+    }
+  ratePos = lengthPos->second.find(dataRate);
+  NS_ASSERT(ratePos != lengthPos->second.end());
+  return  ratePos;
 }
 
 void
 WifiTxStatistics::NotifyDataFailed()
 {
-	RATE_STAT::iterator ratePos =  FillCurrentStatPosition(m_currentSize, m_currentRate);
-	ratePos->second.packetsFailed++;
-	ratePos->second.bytesFailed += m_currentSize;
-
+  RATE_STAT::iterator ratePos =  FillCurrentStatPosition(m_currentSize, m_currentRate);
+  ratePos->second.packetsFailed++;
+  ratePos->second.bytesFailed += m_currentSize;
 }
 
 void
 WifiTxStatistics::NotifyGotAck(uint32_t retryCounter)
 {
-	RATE_STAT::iterator ratePos =  FillCurrentStatPosition(m_currentSize, m_currentRate);
-	ratePos->second.packetsAcked++;
-	ratePos->second.packetsRetried += retryCounter;
-	ratePos->second.bytesAcked+= m_currentSize;
-	ratePos->second.bytesRetried += (m_currentSize*retryCounter);
+  RATE_STAT::iterator ratePos =  FillCurrentStatPosition(m_currentSize, m_currentRate);
+  ratePos->second.packetsAcked++;
+  ratePos->second.packetsRetried += retryCounter;
+  ratePos->second.bytesAcked+= m_currentSize;
+  ratePos->second.bytesRetried += (m_currentSize*retryCounter);
 }
 
 void
 WifiTxStatistics::NotifyRtsSend(uint32_t rtsRate, uint32_t dataLength)
 {
-	m_currentSize = dataLength;
-	m_currentRate = rtsRate;
+  m_currentSize = dataLength;
+  m_currentRate = rtsRate;
 }
 
 void
 WifiTxStatistics::NotifyRtsFailed()
 {
-	RATE_STAT::iterator ratePos =  FillCurrentStatPosition(m_currentSize, m_currentRate);
-	ratePos->second.rtsFailed++;
-	ratePos->second.bytesFailed += m_currentSize;
+  RATE_STAT::iterator ratePos =  FillCurrentStatPosition(m_currentSize, m_currentRate);
+  ratePos->second.rtsFailed++;
+  ratePos->second.bytesFailed += m_currentSize;
 }
 
 void
 WifiTxStatistics::NotifyRtsSuccess(uint32_t retryCounter)
 {
-	RATE_STAT::iterator ratePos =  FillCurrentStatPosition(m_currentSize, m_currentRate);
-	ratePos->second.rtsAcked++;
-	ratePos->second.rtsRetried += retryCounter;
-	ratePos->second.bytesAcked += m_currentSize;
-	ratePos->second.bytesRetried += (m_currentSize*retryCounter);
+  RATE_STAT::iterator ratePos =  FillCurrentStatPosition(m_currentSize, m_currentRate);
+  ratePos->second.rtsAcked++;
+  ratePos->second.rtsRetried += retryCounter;
+  ratePos->second.bytesAcked += m_currentSize;
+  ratePos->second.bytesRetried += (m_currentSize*retryCounter);
 }
 
 void
 WifiTxStatistics::ResetStatistics()
 {
-	for(RATE_LENGTH_STAT::iterator lengthPos = m_stats.begin(); lengthPos != m_stats.end(); lengthPos++)
-		lengthPos->second.clear();
+  for (RATE_LENGTH_STAT::iterator lengthPos = m_stats.begin(); lengthPos != m_stats.end(); lengthPos++)
+    lengthPos->second.clear();
 }
 #if 0
 WifiTxStatistics::SIMPLE_STAT
@@ -160,27 +159,27 @@ WifiTxStatistics::GetTxStatLength()
 WifiTxStatistics::TX_STATISTICS
 WifiTxStatistics::GetTxStatRateLength()
 {
-	TX_STATISTICS retval;
-	retval.statistics = m_stats;
-	retval.lengthInterval = m_maxLength / m_numOfGroups;
-	retval.maxLength = m_maxLength;
-	return retval;
+  TX_STATISTICS retval;
+  retval.statistics = m_stats;
+  retval.lengthInterval = m_maxLength / m_numOfGroups;
+  retval.maxLength = m_maxLength;
+  return retval;
 }
 #if 0
 void
 WifiTxStatistics::Print()
 {
-	for(RATE_LENGTH_STAT::iterator lengthPos = m_stats.begin(); lengthPos != m_stats.end(); lengthPos++)
-	{
-		NS_LOG_UNCOND("\tGROUP = " <<lengthPos->first);
-		for(RATE_STAT::iterator ratePos = lengthPos->second.begin(); ratePos != lengthPos->second.end(); ratePos ++)
-		{
-			NS_LOG_UNCOND("Rate is "<<ratePos->first
-					<<": SUCCESS = "<<ratePos->second.packetsAcked
-					<<", RRETRY = " <<ratePos->second.packetsRetried
-					<<", FAILURE = "<<ratePos->second.packetsFailed);
-		}
-	}
+  for (RATE_LENGTH_STAT::iterator lengthPos = m_stats.begin(); lengthPos != m_stats.end(); lengthPos++)
+    {
+      NS_LOG_UNCOND("\tGROUP = " <<lengthPos->first);
+      for (RATE_STAT::iterator ratePos = lengthPos->second.begin(); ratePos != lengthPos->second.end(); ratePos ++)
+        {
+          NS_LOG_UNCOND("Rate is "<<ratePos->first
+                        <<": SUCCESS = "<<ratePos->second.packetsAcked
+                        <<", RRETRY = " <<ratePos->second.packetsRetried
+                        <<", FAILURE = "<<ratePos->second.packetsFailed);
+        }
+    }
 }
 #endif
 } //namespace ns3
diff --git a/src/devices/wifi/tx-statistics.h b/src/devices/wifi/tx-statistics.h
index 5c62d9cc7..9fb1a1daa 100644
--- a/src/devices/wifi/tx-statistics.h
+++ b/src/devices/wifi/tx-statistics.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -31,74 +31,74 @@
 #include "wifi-mode.h"
 
 namespace ns3 {
-	class WifiTxStatistics : public Object
-	{
-		public:
-			static TypeId		GetTypeId(void);
-			WifiTxStatistics();
-			~WifiTxStatistics();
+class WifiTxStatistics : public Object
+{
+public:
+  static TypeId  GetTypeId(void);
+  WifiTxStatistics();
+  ~WifiTxStatistics();
 
-			struct TxStat
-			{
-				/**
-				 * Packet counters:
-				 */
-				uint32_t	packetsFailed;
-				uint32_t	packetsRetried;
-				uint32_t	packetsAcked;
-				/**
-				 * RTS counters:
-				 */
-				uint32_t	rtsFailed;
-				uint32_t	rtsRetried;
-				uint32_t	rtsAcked;
-				/**
-				 * Byte counters:
-				 */
-				uint64_t	bytesFailed;
-				uint64_t	bytesRetried;
-				uint64_t	bytesAcked;
-			};
-			typedef struct TxStat			SIMPLE_STAT;
-			typedef std::map<uint32_t, SIMPLE_STAT> RATE_STAT;
+  struct TxStat
+  {
+    /**
+     * Packet counters:
+     */
+    uint32_t packetsFailed;
+    uint32_t packetsRetried;
+    uint32_t packetsAcked;
+    /**
+     * RTS counters:
+     */
+    uint32_t rtsFailed;
+    uint32_t rtsRetried;
+    uint32_t rtsAcked;
+    /**
+     * Byte counters:
+     */
+    uint64_t bytesFailed;
+    uint64_t bytesRetried;
+    uint64_t bytesAcked;
+  };
+  typedef struct TxStat   SIMPLE_STAT;
+  typedef std::map<uint32_t, SIMPLE_STAT> RATE_STAT;
 #if 0
-			typedef	std::map<uint16_t, SIMPLE_STAT>	LENGTH_STAT;
+  typedef std::map<uint16_t, SIMPLE_STAT> LENGTH_STAT;
 #endif
-			typedef std::map<uint16_t, RATE_STAT>	RATE_LENGTH_STAT;
+  typedef std::map<uint16_t, RATE_STAT> RATE_LENGTH_STAT;
 
-			void			SetLengthDivisionParams(uint16_t maxLength, uint8_t numOfGroups);
+  void   SetLengthDivisionParams(uint16_t maxLength, uint8_t numOfGroups);
 
-			void			NotifyDataSent(uint16_t length, uint32_t dataRate);
-			void			NotifyDataFailed();
-			void			NotifyGotAck(uint32_t retryCounter);
+  void   NotifyDataSent(uint16_t length, uint32_t dataRate);
+  void   NotifyDataFailed();
+  void   NotifyGotAck(uint32_t retryCounter);
 
-			void			NotifyRtsSend(uint32_t rtsRate, uint32_t dataLength);
-			void			NotifyRtsRetried();
-			void			NotifyRtsFailed();
-			void			NotifyRtsSuccess(uint32_t retryCounter);
+  void   NotifyRtsSend(uint32_t rtsRate, uint32_t dataLength);
+  void   NotifyRtsRetried();
+  void   NotifyRtsFailed();
+  void   NotifyRtsSuccess(uint32_t retryCounter);
 
-			void			ResetStatistics();
+  void   ResetStatistics();
 #if 0
-			SIMPLE_STAT		GetTxStatCommon();
-			RATE_STAT		GetTxStatRate();
-			LENGTH_STAT		GetTxStatLength();
+  SIMPLE_STAT  GetTxStatCommon();
+  RATE_STAT  GetTxStatRate();
+  LENGTH_STAT  GetTxStatLength();
 #endif
-			typedef struct {
-				RATE_LENGTH_STAT	statistics;
-				uint16_t		lengthInterval;
-				uint16_t		maxLength;
-			} TX_STATISTICS;
-			TX_STATISTICS		GetTxStatRateLength();
-		private:
-			RATE_STAT::iterator	FillCurrentStatPosition(uint16_t length, uint32_t dataRate);
-			//DEBUG PURPOSE
-			//void			Print();
-			RATE_LENGTH_STAT	m_stats;
-			bool			m_isTx;
-			uint8_t			m_numOfGroups;
-			uint16_t		m_maxLength;
-			uint16_t		m_currentSize;
-			uint32_t		m_currentRate;
-	};
+  typedef struct {
+    RATE_LENGTH_STAT statistics;
+    uint16_t  lengthInterval;
+    uint16_t  maxLength;
+  } TX_STATISTICS;
+  TX_STATISTICS  GetTxStatRateLength();
+private:
+  RATE_STAT::iterator FillCurrentStatPosition(uint16_t length, uint32_t dataRate);
+  //DEBUG PURPOSE
+  //void   Print();
+  RATE_LENGTH_STAT m_stats;
+  bool   m_isTx;
+  uint8_t   m_numOfGroups;
+  uint16_t  m_maxLength;
+  uint16_t  m_currentSize;
+  uint32_t  m_currentRate;
+};
 } //namespace ns3
 #endif
diff --git a/src/helper/hwmp-helper.cc b/src/helper/hwmp-helper.cc
index 1f8be12f2..f1a5adab4 100644
--- a/src/helper/hwmp-helper.cc
+++ b/src/helper/hwmp-helper.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
diff --git a/src/helper/hwmp-helper.h b/src/helper/hwmp-helper.h
index 1f8be12f2..f1a5adab4 100644
--- a/src/helper/hwmp-helper.h
+++ b/src/helper/hwmp-helper.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
diff --git a/src/helper/mesh-wifi-helper.cc b/src/helper/mesh-wifi-helper.cc
index 64c1d32ce..c86eefaf5 100644
--- a/src/helper/mesh-wifi-helper.cc
+++ b/src/helper/mesh-wifi-helper.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -36,12 +36,11 @@
 #include "ns3/hwmp.h"
 
 NS_LOG_COMPONENT_DEFINE ("MeshWifiHelper");
-namespace ns3
-{
+namespace ns3 {
 
 MeshWifiHelper::MeshWifiHelper ()
 {
-	//m_deviceFactory.SetTypeId ("ns3::L2RoutingNetDevice");
+  //m_deviceFactory.SetTypeId ("ns3::L2RoutingNetDevice");
 }
 
 MeshWifiHelper::~MeshWifiHelper ()
@@ -50,169 +49,169 @@ MeshWifiHelper::~MeshWifiHelper ()
 
 void
 MeshWifiHelper::SetRemoteStationManager (std::string type,
-		std::string n0, const AttributeValue &v0,
-		std::string n1, const AttributeValue &v1,
-		std::string n2, const AttributeValue &v2,
-		std::string n3, const AttributeValue &v3,
-		std::string n4, const AttributeValue &v4,
-		std::string n5, const AttributeValue &v5,
-		std::string n6, const AttributeValue &v6,
-		std::string n7, const AttributeValue &v7)
+    std::string n0, const AttributeValue &v0,
+    std::string n1, const AttributeValue &v1,
+    std::string n2, const AttributeValue &v2,
+    std::string n3, const AttributeValue &v3,
+    std::string n4, const AttributeValue &v4,
+    std::string n5, const AttributeValue &v5,
+    std::string n6, const AttributeValue &v6,
+    std::string n7, const AttributeValue &v7)
 {
-	m_stationManager = ObjectFactory ();
-	m_stationManager.SetTypeId (type);
-	m_stationManager.Set (n0, v0);
-	m_stationManager.Set (n1, v1);
-	m_stationManager.Set (n2, v2);
-	m_stationManager.Set (n3, v3);
-	m_stationManager.Set (n4, v4);
-	m_stationManager.Set (n5, v5);
-	m_stationManager.Set (n6, v6);
-	m_stationManager.Set (n7, v7);
+  m_stationManager = ObjectFactory ();
+  m_stationManager.SetTypeId (type);
+  m_stationManager.Set (n0, v0);
+  m_stationManager.Set (n1, v1);
+  m_stationManager.Set (n2, v2);
+  m_stationManager.Set (n3, v3);
+  m_stationManager.Set (n4, v4);
+  m_stationManager.Set (n5, v5);
+  m_stationManager.Set (n6, v6);
+  m_stationManager.Set (n7, v7);
 }
 
 void
 MeshWifiHelper::SetMac (std::string type,
-		std::string n0, const AttributeValue &v0,
-		std::string n1, const AttributeValue &v1,
-		std::string n2, const AttributeValue &v2,
-		std::string n3, const AttributeValue &v3,
-		std::string n4, const AttributeValue &v4,
-		std::string n5, const AttributeValue &v5,
-		std::string n6, const AttributeValue &v6,
-		std::string n7, const AttributeValue &v7)
+                        std::string n0, const AttributeValue &v0,
+                        std::string n1, const AttributeValue &v1,
+                        std::string n2, const AttributeValue &v2,
+                        std::string n3, const AttributeValue &v3,
+                        std::string n4, const AttributeValue &v4,
+                        std::string n5, const AttributeValue &v5,
+                        std::string n6, const AttributeValue &v6,
+                        std::string n7, const AttributeValue &v7)
 {
-	m_meshMac = ObjectFactory ();
-	m_meshMac.SetTypeId (type);
-	m_meshMac.Set (n0, v0);
-	m_meshMac.Set (n1, v1);
-	m_meshMac.Set (n2, v2);
-	m_meshMac.Set (n3, v3);
-	m_meshMac.Set (n4, v4);
-	m_meshMac.Set (n5, v5);
-	m_meshMac.Set (n6, v6);
-	m_meshMac.Set (n7, v7);
+  m_meshMac = ObjectFactory ();
+  m_meshMac.SetTypeId (type);
+  m_meshMac.Set (n0, v0);
+  m_meshMac.Set (n1, v1);
+  m_meshMac.Set (n2, v2);
+  m_meshMac.Set (n3, v3);
+  m_meshMac.Set (n4, v4);
+  m_meshMac.Set (n5, v5);
+  m_meshMac.Set (n6, v6);
+  m_meshMac.Set (n7, v7);
 }
 
 void
 MeshWifiHelper::SetL2RoutingProtocol(std::string type,
-		std::string n0, const AttributeValue &v0,
-		std::string n1, const AttributeValue &v1,
-		std::string n2, const AttributeValue &v2,
-		std::string n3, const AttributeValue &v3,
-		std::string n4, const AttributeValue &v4,
-		std::string n5, const AttributeValue &v5,
-		std::string n6, const AttributeValue &v6,
-		std::string n7, const AttributeValue &v7,
-		std::string n8, const AttributeValue &v8,
-		std::string n9, const AttributeValue &v9)
+                                     std::string n0, const AttributeValue &v0,
+                                     std::string n1, const AttributeValue &v1,
+                                     std::string n2, const AttributeValue &v2,
+                                     std::string n3, const AttributeValue &v3,
+                                     std::string n4, const AttributeValue &v4,
+                                     std::string n5, const AttributeValue &v5,
+                                     std::string n6, const AttributeValue &v6,
+                                     std::string n7, const AttributeValue &v7,
+                                     std::string n8, const AttributeValue &v8,
+                                     std::string n9, const AttributeValue &v9)
 {
-	m_routingProtocol = ObjectFactory ();
-	m_routingProtocol.SetTypeId (type);
-	m_routingProtocol.Set (n0, v0);
-	m_routingProtocol.Set (n1, v1);
-	m_routingProtocol.Set (n2, v2);
-	m_routingProtocol.Set (n3, v3);
-	m_routingProtocol.Set (n4, v4);
-	m_routingProtocol.Set (n5, v5);
-	m_routingProtocol.Set (n6, v6);
-	m_routingProtocol.Set (n7, v7);
+  m_routingProtocol = ObjectFactory ();
+  m_routingProtocol.SetTypeId (type);
+  m_routingProtocol.Set (n0, v0);
+  m_routingProtocol.Set (n1, v1);
+  m_routingProtocol.Set (n2, v2);
+  m_routingProtocol.Set (n3, v3);
+  m_routingProtocol.Set (n4, v4);
+  m_routingProtocol.Set (n5, v5);
+  m_routingProtocol.Set (n6, v6);
+  m_routingProtocol.Set (n7, v7);
 }
 
 void
 MeshWifiHelper::SetL2RoutingNetDevice(std::string type,
-		std::string n0, const AttributeValue &v0,
-		std::string n1, const AttributeValue &v1,
-		std::string n2, const AttributeValue &v2,
-		std::string n3, const AttributeValue &v3,
-		std::string n4, const AttributeValue &v4,
-		std::string n5, const AttributeValue &v5,
-		std::string n6, const AttributeValue &v6,
-		std::string n7, const AttributeValue &v7,
-		std::string n8, const AttributeValue &v8,
-		std::string n9, const AttributeValue &v9)
+                                      std::string n0, const AttributeValue &v0,
+                                      std::string n1, const AttributeValue &v1,
+                                      std::string n2, const AttributeValue &v2,
+                                      std::string n3, const AttributeValue &v3,
+                                      std::string n4, const AttributeValue &v4,
+                                      std::string n5, const AttributeValue &v5,
+                                      std::string n6, const AttributeValue &v6,
+                                      std::string n7, const AttributeValue &v7,
+                                      std::string n8, const AttributeValue &v8,
+                                      std::string n9, const AttributeValue &v9)
 {
-	m_deviceFactory = ObjectFactory ();
-	m_deviceFactory.SetTypeId (type);
-	m_deviceFactory.Set (n0, v0);
-	m_deviceFactory.Set (n1, v1);
-	m_deviceFactory.Set (n2, v2);
-	m_deviceFactory.Set (n3, v3);
-	m_deviceFactory.Set (n4, v4);
-	m_deviceFactory.Set (n5, v5);
-	m_deviceFactory.Set (n6, v6);
-	m_deviceFactory.Set (n7, v7);
+  m_deviceFactory = ObjectFactory ();
+  m_deviceFactory.SetTypeId (type);
+  m_deviceFactory.Set (n0, v0);
+  m_deviceFactory.Set (n1, v1);
+  m_deviceFactory.Set (n2, v2);
+  m_deviceFactory.Set (n3, v3);
+  m_deviceFactory.Set (n4, v4);
+  m_deviceFactory.Set (n5, v5);
+  m_deviceFactory.Set (n6, v6);
+  m_deviceFactory.Set (n7, v7);
 }
 
 void
 MeshWifiHelper::SetPeerLinkManager (std::string type,
-		std::string n0, const AttributeValue &v0,
-		std::string n1, const AttributeValue &v1,
-		std::string n2, const AttributeValue &v2,
-		std::string n3, const AttributeValue &v3,
-		std::string n4, const AttributeValue &v4,
-		std::string n5, const AttributeValue &v5,
-		std::string n6, const AttributeValue &v6,
-		std::string n7, const AttributeValue &v7,
-		std::string n8, const AttributeValue &v8,
-		std::string n9, const AttributeValue &v9)
+                                    std::string n0, const AttributeValue &v0,
+                                    std::string n1, const AttributeValue &v1,
+                                    std::string n2, const AttributeValue &v2,
+                                    std::string n3, const AttributeValue &v3,
+                                    std::string n4, const AttributeValue &v4,
+                                    std::string n5, const AttributeValue &v5,
+                                    std::string n6, const AttributeValue &v6,
+                                    std::string n7, const AttributeValue &v7,
+                                    std::string n8, const AttributeValue &v8,
+                                    std::string n9, const AttributeValue &v9)
 {
-	m_peerManager = ObjectFactory ();
-	m_peerManager.SetTypeId (type);
-	m_peerManager.Set (n0, v0);
-	m_peerManager.Set (n1, v1);
-	m_peerManager.Set (n2, v2);
-	m_peerManager.Set (n3, v3);
-	m_peerManager.Set (n4, v4);
-	m_peerManager.Set (n5, v5);
-	m_peerManager.Set (n6, v6);
-	m_peerManager.Set (n7, v7);
-	m_peerManager.Set (n8, v8);
-	m_peerManager.Set (n9, v9);
+  m_peerManager = ObjectFactory ();
+  m_peerManager.SetTypeId (type);
+  m_peerManager.Set (n0, v0);
+  m_peerManager.Set (n1, v1);
+  m_peerManager.Set (n2, v2);
+  m_peerManager.Set (n3, v3);
+  m_peerManager.Set (n4, v4);
+  m_peerManager.Set (n5, v5);
+  m_peerManager.Set (n6, v6);
+  m_peerManager.Set (n7, v7);
+  m_peerManager.Set (n8, v8);
+  m_peerManager.Set (n9, v9);
 }
 
 NetDeviceContainer
 MeshWifiHelper::Install (const WifiPhyHelper &phyHelper, NodeContainer c, uint8_t numOfPorts) const
-{
-	NetDeviceContainer devices;
-	for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
-	{
-		Ptr<Node> node = *i;
-		Ptr<L2RoutingNetDevice> virtualDevice = m_deviceFactory.Create<L2RoutingNetDevice> ();
-		Ptr<WifiPeerManager> pPeer = m_peerManager.Create<WifiPeerManager > ();
-		devices.Add (virtualDevice);
-		std::vector<Ptr<WifiNetDevice> > nodeDevices;
-		for (uint8_t k=0; k<numOfPorts; k++)
-		{
-			Ptr<WifiNetDevice> device = CreateObject<WifiNetDevice> ();
-			Ptr<MeshWifiMac> mac = m_meshMac.Create<MeshWifiMac> ();
-			Ptr<WifiRemoteStationManager> manager = m_stationManager.Create<WifiRemoteStationManager> ();
-			Ptr<WifiPhy> phy = phyHelper.Create (node, device);
-			mac->SetAddress (Mac48Address::Allocate ());
-			device->SetMac (mac);
-			device->SetPhy (phy);
-			device->SetRemoteStationManager (manager);
-			//create L2RoutingNetDevice and add WifiNetDevice to it
-			node->AddDevice(device);
-			nodeDevices.push_back(device);
-		}
-		node -> AddDevice(virtualDevice);
-		for (std::vector<Ptr<WifiNetDevice> > ::iterator iter=nodeDevices.begin();iter!=nodeDevices.end(); ++iter)
-			virtualDevice->AddPort(*iter);
-		// nodeDevice.pop_back()
-		pPeer->AttachPorts(nodeDevices);
-		Ptr<L2RoutingProtocol> routingProtocol = m_routingProtocol.Create <L2RoutingProtocol>();
-		virtualDevice->AttachProtocol(routingProtocol);
-		//hwmp->SetRoot(device->GetIfIndex(), Seconds(5));
-		nodeDevices.clear();
-	}
-	return devices;
-}
+  {
+    NetDeviceContainer devices;
+    for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
+      {
+        Ptr<Node> node = *i;
+        Ptr<L2RoutingNetDevice> virtualDevice = m_deviceFactory.Create<L2RoutingNetDevice> ();
+        Ptr<WifiPeerManager> pPeer = m_peerManager.Create<WifiPeerManager > ();
+        devices.Add (virtualDevice);
+        std::vector<Ptr<WifiNetDevice> > nodeDevices;
+        for (uint8_t k=0; k<numOfPorts; k++)
+          {
+            Ptr<WifiNetDevice> device = CreateObject<WifiNetDevice> ();
+            Ptr<MeshWifiMac> mac = m_meshMac.Create<MeshWifiMac> ();
+            Ptr<WifiRemoteStationManager> manager = m_stationManager.Create<WifiRemoteStationManager> ();
+            Ptr<WifiPhy> phy = phyHelper.Create (node, device);
+            mac->SetAddress (Mac48Address::Allocate ());
+            device->SetMac (mac);
+            device->SetPhy (phy);
+            device->SetRemoteStationManager (manager);
+            //create L2RoutingNetDevice and add WifiNetDevice to it
+            node->AddDevice(device);
+            nodeDevices.push_back(device);
+          }
+        node -> AddDevice(virtualDevice);
+        for (std::vector<Ptr<WifiNetDevice> > ::iterator iter=nodeDevices.begin();iter!=nodeDevices.end(); ++iter)
+          virtualDevice->AddPort(*iter);
+        // nodeDevice.pop_back()
+        pPeer->AttachPorts(nodeDevices);
+        Ptr<L2RoutingProtocol> routingProtocol = m_routingProtocol.Create <L2RoutingProtocol>();
+        virtualDevice->AttachProtocol(routingProtocol);
+        //hwmp->SetRoot(device->GetIfIndex(), Seconds(5));
+        nodeDevices.clear();
+      }
+    return devices;
+  }
 
 NetDeviceContainer
 MeshWifiHelper::Install (const WifiPhyHelper &phy, Ptr<Node> node, uint8_t numOfPorts) const
-{
-	return Install (phy, NodeContainer (node), numOfPorts);
-}
+  {
+    return Install (phy, NodeContainer (node), numOfPorts);
+  }
 
 } //namespace ns3
diff --git a/src/helper/mesh-wifi-helper.h b/src/helper/mesh-wifi-helper.h
index 142af28fe..e4c2fa94f 100644
--- a/src/helper/mesh-wifi-helper.h
+++ b/src/helper/mesh-wifi-helper.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -20,7 +20,7 @@
 
 
 #ifndef _MESHWIFIHELPER_H
-#define	_MESHWIFIHELPER_H
+#define _MESHWIFIHELPER_H
 
 #include "ns3/wifi-net-device.h"
 #include "ns3/l2-routing-net-device.h"
@@ -29,95 +29,94 @@
 #include "ns3/mesh-wifi-peer-manager.h"
 #include "wifi-helper.h"
 
-namespace ns3
+namespace ns3 {
+class WifiChannel;
+
+class MeshWifiHelper
 {
-	class WifiChannel;
+public:
+  MeshWifiHelper ();
+  virtual ~MeshWifiHelper ();
 
-	class MeshWifiHelper
-	{
-		public:
-			MeshWifiHelper ();
-			virtual ~MeshWifiHelper ();
+  /**
+   * \param type the type of peer manager to use.
+   * \param n0 the name of the attribute to set in the peer manager.
+   * \param v0 the value of the attribute to set in the peer manager.
+   * etc.
+   *
+   */
+  void SetRemoteStationManager (std::string type,
+                                std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
+                                std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
+                                std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
+                                std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
+                                std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
+                                std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
+                                std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
+                                std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ());
 
-			/**
-			 * \param type the type of peer manager to use.
-			 * \param n0 the name of the attribute to set in the peer manager.
-			 * \param v0 the value of the attribute to set in the peer manager.
-			 * etc.
-			 *
-			 */
-			void SetRemoteStationManager (std::string type,
-					std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
-					std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
-					std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
-					std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
-					std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
-					std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
-					std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
-					std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ());
+  /**
+   * \param type the type of ns3::WifiMac to create.
+   * \param n0 the name of the attribute to set
+   * \param v0 the value of the attribute to set
+   *
+   * All the attributes specified in this method should exist
+   * in the requested mac.
+   */
+  void SetMac (std::string type,
+               std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
+               std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
+               std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
+               std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
+               std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
+               std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
+               std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
+               std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ());
 
-			/**
-			 * \param type the type of ns3::WifiMac to create.
-			 * \param n0 the name of the attribute to set
-			 * \param v0 the value of the attribute to set
-			 *
-			 * All the attributes specified in this method should exist
-			 * in the requested mac.
-			 */
-			void SetMac (std::string type,
-					std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
-					std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
-					std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
-					std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
-					std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
-					std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
-					std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
-					std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue ());
+  void SetPeerLinkManager (std::string type,
+                           std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
+                           std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
+                           std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
+                           std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
+                           std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
+                           std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
+                           std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
+                           std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
+                           std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
+                           std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue ());
+  void SetL2RoutingProtocol(std::string type,
+                            std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
+                            std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
+                            std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
+                            std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
+                            std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
+                            std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
+                            std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
+                            std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
+                            std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
+                            std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue ());
 
-			void SetPeerLinkManager (std::string type,
-					std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
-					std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
-					std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
-					std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
-					std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
-					std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
-					std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
-					std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
-					std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
-					std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue ());
-			void SetL2RoutingProtocol(std::string type,
-					std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
-					std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
-					std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
-					std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
-					std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
-					std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
-					std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
-					std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
-					std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
-					std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue ());
-
-			void SetL2RoutingNetDevice(std::string type,
-					std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
-					std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
-					std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
-					std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
-					std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
-					std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
-					std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
-					std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
-					std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
-					std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue ());
-			NetDeviceContainer Install (const WifiPhyHelper &phyHelper, NodeContainer c, uint8_t numOfPorts) const;
-			NetDeviceContainer Install (const WifiPhyHelper &phy, Ptr<Node> node, uint8_t numOfPorts) const;
-		private:
-			ObjectFactory m_stationManager;
-			ObjectFactory m_meshMac;
-			ObjectFactory m_peerManager;
-			//L2routing:
-			ObjectFactory m_deviceFactory;
-			ObjectFactory m_routingProtocol;
-	};
+  void SetL2RoutingNetDevice(std::string type,
+                             std::string n0 = "", const AttributeValue &v0 = EmptyAttributeValue (),
+                             std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
+                             std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
+                             std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
+                             std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue (),
+                             std::string n5 = "", const AttributeValue &v5 = EmptyAttributeValue (),
+                             std::string n6 = "", const AttributeValue &v6 = EmptyAttributeValue (),
+                             std::string n7 = "", const AttributeValue &v7 = EmptyAttributeValue (),
+                             std::string n8 = "", const AttributeValue &v8 = EmptyAttributeValue (),
+                             std::string n9 = "", const AttributeValue &v9 = EmptyAttributeValue ());
+  NetDeviceContainer Install (const WifiPhyHelper &phyHelper, NodeContainer c, uint8_t numOfPorts) const;
+  NetDeviceContainer Install (const WifiPhyHelper &phy, Ptr<Node> node, uint8_t numOfPorts) const;
+private:
+  ObjectFactory m_stationManager;
+  ObjectFactory m_meshMac;
+  ObjectFactory m_peerManager;
+  //L2routing:
+  ObjectFactory m_deviceFactory;
+  ObjectFactory m_routingProtocol;
+};
 }//namespace ns3
-#endif	/* _MESHWIFIHELPER_H */
+#endif /* _MESHWIFIHELPER_H */
 
diff --git a/src/node/l2-routing-protocol.cc b/src/node/l2-routing-protocol.cc
index ac19dc0dd..21446a3ac 100644
--- a/src/node/l2-routing-protocol.cc
+++ b/src/node/l2-routing-protocol.cc
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -32,9 +32,9 @@ NS_OBJECT_ENSURE_REGISTERED (L2RoutingProtocol);
 TypeId
 L2RoutingProtocol::GetTypeId (void)
 {
-	static TypeId tid = TypeId ("ns3::L2RoutingProtocol")
-		.SetParent<Object> ();
-	return tid;
+  static TypeId tid = TypeId ("ns3::L2RoutingProtocol")
+                      .SetParent<Object> ();
+  return tid;
 }
 
 L2RoutingProtocol::~L2RoutingProtocol ()
diff --git a/src/node/l2-routing-protocol.h b/src/node/l2-routing-protocol.h
index 2979ad3e8..38c1ba856 100644
--- a/src/node/l2-routing-protocol.h
+++ b/src/node/l2-routing-protocol.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -45,118 +45,115 @@ class Packet;
  */
 class L2RoutingProtocol : public Object
 {
-	public:
-		static TypeId GetTypeId();
-		virtual ~L2RoutingProtocol();
-		/**
-		 * \brief Callback to be invoked when route discovery
-		 * procedure is completed
-		 * \param bool flag indicating whether a route was
-		 * actually found and all needed information is added
-		 * to the packet succesfully
-		 * \param Ptr<Packet> is packet, for which the route
-		 * was resolved
-		 * \attention All needed information for MAC layer
-		 * must be stored in proper tags (like in case of
-		 * HWMP, when WifiMacHeader needs address of next
-		 * hop), or must be added as a packet header(if MAC
-		 * does not need any additional information). So, the
-		 * packet is returned back to L2RoutingNetDevice looks
-		 * like a pure packet with ethernet header (i.e data
-		 * +src +dst + protocol). All information needed to
-		 * L2RoutingNetDevice is outgoing port ID.
-		 * \param Mac48Address Source address of the packet
-		 * \param Mac48Address Destiation address of the
-		 * packet
-		 * \param uint16_t Ethernet 'Protocol' field - stored
-		 * in protocol, needed to form a proper MAC-layer
-		 * header.
-		 * \param uint32_t Output port
-		 */
-typedef Callback<
-	void,
-	bool,
-	Ptr<Packet>,
-	Mac48Address,
-	Mac48Address,
-	uint16_t,
-	uint32_t
-		>
-		RouteReplyCallback;
-		/**
-		 * \brief All packets must go through RequestRoute
-		 * \returns Can the route be discovered or not
-		 * \param sourceIface The incoming interface of the
-		 * packet
-		 * \param source Source address of the packet
-		 * \param destination Destination address of the
-		 * packet
-		 * \param packet The packet to be resolved (needed the
-		 * whole packet, because we can add tags or headers).
-		 * \param protocolType The protocol ID (must be stored
-		 * for route discovery time to form a proper MAC-layer
-		 * header).
-		 * \param routeReply Callback to be invoked after route
-		 * discovery procedure.
-		 */
-		virtual bool RequestRoute(
-				uint32_t		sourceIface,
-				const Mac48Address	source,
-				const Mac48Address	destination,
-				Ptr<Packet>		packet,
-				uint16_t		protocolType,
-				RouteReplyCallback	routeReply
-				) = 0;
-		/**
-		 * \brief Attaches ports to the L2RoutingProtocols,
-		 * \returns False if there are not proper devices (like
-		 * HWMP, which requires only WifiNetDevice and works
-		 * only above MeshWifiMac).
-		 * \param ports The array of ports.
-		 */
-		virtual bool AttachPorts(std::vector<Ptr<NetDevice> > ports) = 0;
-		/**
-		 * \brief L2Routing protocol must know the
-		 * L2RoutingNetDevice ID to determine packets as 'came
-		 * from upper layer' and 'received from network' (for
-		 * example, to manage TTL).
-		 * \param interface The interface ID of
-		 * L2RoutingNetDevice
-		 */
-		virtual void SetIfIndex(uint32_t interface) = 0;
-	protected:
-		struct QueuedPacket {
-			Ptr<Packet>	pkt;
-			Mac48Address	dst;
-			Mac48Address	src;
-			uint16_t	protocol;
-			uint32_t	inPort;
-			RouteReplyCallback reply;
-		};
-		/**
-		 * \brief Set Max queue size per destinztion
-		 * \details Routing Queue is implemented inside the
-		 * routing protocol and keeps one queue per
-		 * destination (to make it easier to find resolved and
-		 * timed out packets).
-		 * \param maxPacketsPerDestination Packets per
-		 * destination that can be stored inside protocol.
-		 */
-		virtual void SetMaxQueueSize(int maxPacketsPerDestination) = 0;
-		/**
-		 * \brief Queue packet with 'Ethernet header'
-		 * \returns false if the queue is full.
-		 */
-		virtual bool QueuePacket(struct QueuedPacket packet) = 0;
-		/**
-		 * \brief Deques packet with 'Ethernet header'
-		 * \returns Ptr<packet> (NULL if queue is empty), src,
-		 * dst, protocol ID, incoming port ID, and reply
-		 * callback
-		 * \param destination The destination address, which
-		 * identifyes queue.
-		 */
-		virtual struct QueuedPacket DequeuePacket(Mac48Address destination) = 0;
+public:
+  static TypeId GetTypeId();
+  virtual ~L2RoutingProtocol();
+  /**
+   * \brief Callback to be invoked when route discovery
+   * procedure is completed
+   * \param bool flag indicating whether a route was
+   * actually found and all needed information is added
+   * to the packet succesfully
+   * \param Ptr<Packet> is packet, for which the route
+   * was resolved
+   * \attention All needed information for MAC layer
+   * must be stored in proper tags (like in case of
+   * HWMP, when WifiMacHeader needs address of next
+   * hop), or must be added as a packet header(if MAC
+   * does not need any additional information). So, the
+   * packet is returned back to L2RoutingNetDevice looks
+   * like a pure packet with ethernet header (i.e data
+   * +src +dst + protocol). All information needed to
+   * L2RoutingNetDevice is outgoing port ID.
+   * \param Mac48Address Source address of the packet
+   * \param Mac48Address Destiation address of the
+   * packet
+   * \param uint16_t Ethernet 'Protocol' field - stored
+   * in protocol, needed to form a proper MAC-layer
+   * header.
+   * \param uint32_t Output port
+   */
+  typedef Callback<void,
+                   bool,
+                   Ptr<Packet>,
+                   Mac48Address,
+                   Mac48Address,
+                   uint16_t,
+                   uint32_t >   RouteReplyCallback;
+  /**
+   * \brief All packets must go through RequestRoute
+   * \returns Can the route be discovered or not
+   * \param sourceIface The incoming interface of the
+   * packet
+   * \param source Source address of the packet
+   * \param destination Destination address of the
+   * packet
+   * \param packet The packet to be resolved (needed the
+   * whole packet, because we can add tags or headers).
+   * \param protocolType The protocol ID (must be stored
+   * for route discovery time to form a proper MAC-layer
+   * header).
+   * \param routeReply Callback to be invoked after route
+   * discovery procedure.
+   */
+  virtual bool RequestRoute(
+    uint32_t  sourceIface,
+    const Mac48Address source,
+    const Mac48Address destination,
+    Ptr<Packet>  packet,
+    uint16_t  protocolType,
+    RouteReplyCallback routeReply
+  ) = 0;
+  /**
+   * \brief Attaches ports to the L2RoutingProtocols,
+   * \returns False if there are not proper devices (like
+   * HWMP, which requires only WifiNetDevice and works
+   * only above MeshWifiMac).
+   * \param ports The array of ports.
+   */
+  virtual bool AttachPorts(std::vector<Ptr<NetDevice> > ports) = 0;
+  /**
+   * \brief L2Routing protocol must know the
+   * L2RoutingNetDevice ID to determine packets as 'came
+   * from upper layer' and 'received from network' (for
+   * example, to manage TTL).
+   * \param interface The interface ID of
+   * L2RoutingNetDevice
+   */
+  virtual void SetIfIndex(uint32_t interface) = 0;
+protected:
+  struct QueuedPacket {
+    Ptr<Packet> pkt;
+    Mac48Address dst;
+    Mac48Address src;
+    uint16_t protocol;
+    uint32_t inPort;
+    RouteReplyCallback reply;
+  };
+  /**
+   * \brief Set Max queue size per destinztion
+   * \details Routing Queue is implemented inside the
+   * routing protocol and keeps one queue per
+   * destination (to make it easier to find resolved and
+   * timed out packets).
+   * \param maxPacketsPerDestination Packets per
+   * destination that can be stored inside protocol.
+   */
+  virtual void SetMaxQueueSize(int maxPacketsPerDestination) = 0;
+  /**
+   * \brief Queue packet with 'Ethernet header'
+   * \returns false if the queue is full.
+   */
+  virtual bool QueuePacket(struct QueuedPacket packet) = 0;
+  /**
+   * \brief Deques packet with 'Ethernet header'
+   * \returns Ptr<packet> (NULL if queue is empty), src,
+   * dst, protocol ID, incoming port ID, and reply
+   * callback
+   * \param destination The destination address, which
+   * identifyes queue.
+   */
+  virtual struct QueuedPacket DequeuePacket(Mac48Address destination) = 0;
 };
 }//namespace ns3
 #endif
diff --git a/src/node/mac48-address-comparator.h b/src/node/mac48-address-comparator.h
index 6eec23079..5a40449ee 100644
--- a/src/node/mac48-address-comparator.h
+++ b/src/node/mac48-address-comparator.h
@@ -3,7 +3,7 @@
  * Copyright (c) 2008,2009 IITP RAS
  *
  * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as 
+ * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation;
  *
  * This program is distributed in the hope that it will be useful,
@@ -24,17 +24,17 @@
 #include "ns3/mac48-address.h"
 namespace ns3 {
 struct mac48addrComparator
-			{
-				bool operator()(const Mac48Address addr1, Mac48Address addr2) const
-				{
-					uint8_t s1[6], s2[6];
-					addr1.CopyTo(s1);
-					addr2.CopyTo(s2);
-					for(int i = 0; i < 6; i ++)
-						if(s1[i] > s2[i])
-							return true;
-					return false;
-				}
-			};
+{
+  bool operator()(const Mac48Address addr1, Mac48Address addr2) const
+  {
+    uint8_t s1[6], s2[6];
+    addr1.CopyTo(s1);
+    addr2.CopyTo(s2);
+    for (int i = 0; i < 6; i ++)
+      if (s1[i] > s2[i])
+        return true;
+    return false;
+  }
+};
 }//namespace ns3
 #endif