/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

 /*

  * Copyright (c) 2005,2006 INRIA

  *

  * 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;

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * 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: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

  */

 #include "wifi-net-device.h"

 #include "wifi-mac.h"

 #include "wifi-phy.h"

 #include "wifi-remote-station-manager.h"

 #include "wifi-channel.h"

 #include "ns3/llc-snap-header.h"

 #include "ns3/packet.h"

 #include "ns3/uinteger.h"

 #include "ns3/pointer.h"

 #include "ns3/node.h"

 #include "ns3/trace-source-accessor.h"

 namespace ns3 {

 NS_OBJECT_ENSURE_REGISTERED (WifiNetDevice);

 TypeId 

 WifiNetDevice::GetTypeId (void)

 {

   static TypeId tid = TypeId ("ns3::WifiNetDevice")

     .SetParent<NetDevice> ()

     .AddAttribute ("Channel", "The channel attached to this device",

                    PointerValue (),

                    MakePointerAccessor (&WifiNetDevice::DoGetChannel,

                                         &WifiNetDevice::SetChannel),

                    MakePointerChecker<WifiChannel> ())

     .AddAttribute ("Phy", "The PHY layer attached to this device.",

                    PointerValue (),

                    MakePointerAccessor (&WifiNetDevice::GetPhy,

                                         &WifiNetDevice::SetPhy),

                    MakePointerChecker<WifiPhy> ())

     .AddAttribute ("Mac", "The MAC layer attached to this device.",

                    PointerValue (),

                    MakePointerAccessor (&WifiNetDevice::GetMac,

                                         &WifiNetDevice::SetMac),

                    MakePointerChecker<WifiMac> ())

     .AddAttribute ("RemoteStationManager", "The station manager attached to this device.",

                    PointerValue (),

                    MakePointerAccessor (&WifiNetDevice::SetRemoteStationManager,

                                         &WifiNetDevice::GetRemoteStationManager),

                    MakePointerChecker<WifiRemoteStationManager> ())

     .AddTraceSource ("Rx", "Received payload from the MAC layer.",

                      MakeTraceSourceAccessor (&WifiNetDevice::m_rxLogger))

     .AddTraceSource ("Tx", "Send payload to the MAC layer.",

                      MakeTraceSourceAccessor (&WifiNetDevice::m_txLogger))

     ;

   return tid;

 }

 WifiNetDevice::WifiNetDevice ()

   : m_mtu (0)

 {}

 WifiNetDevice::~WifiNetDevice ()

 {}

 void

 WifiNetDevice::DoDispose (void)

 {

   m_node = 0;

   m_mac->Dispose ();

   m_phy->Dispose ();

   m_stationManager->Dispose ();

   m_mac = 0;

   m_phy = 0;

   m_channel = 0;

   m_stationManager = 0;

   // chain up.

   NetDevice::DoDispose ();

 }

 void 

 WifiNetDevice::SetMac (Ptr<WifiMac> mac)

 {

   m_mac = mac;

   if (m_mac != 0)

     {

       if (m_stationManager != 0)

         {

           m_mac->SetWifiRemoteStationManager (m_stationManager);

         }

       if (m_phy != 0)

         {

           m_mac->SetWifiPhy (m_phy);

         }

       m_mac->SetForwardUpCallback (MakeCallback (&WifiNetDevice::ForwardUp, this));

       m_mac->SetLinkUpCallback (MakeCallback (&WifiNetDevice::LinkUp, this));

       m_mac->SetLinkDownCallback (MakeCallback (&WifiNetDevice::LinkDown, this));

     }

 }

 void 

 WifiNetDevice::SetPhy (Ptr<WifiPhy> phy)

 {

   m_phy = phy;

   if (m_phy != 0)

     {

       if (m_channel != 0)

         {

           m_channel->Add (this, m_phy);

           m_phy->SetChannel (m_channel);

         }

       if (m_stationManager != 0)

         {

           m_stationManager->SetupPhy (m_phy);

         }

       if (m_mac != 0)

         {

           m_mac->SetWifiPhy (m_phy);

         }

     }

 }

 void 

 WifiNetDevice::SetRemoteStationManager (Ptr<WifiRemoteStationManager> manager)

 {

   m_stationManager = manager;

   if (m_stationManager != 0)

     {

       if (m_phy != 0)

         {

           m_stationManager->SetupPhy (m_phy);

         }

       if (m_mac != 0)

         {

           m_mac->SetWifiRemoteStationManager (m_stationManager);

         }

     }

 }

 void 

 WifiNetDevice::SetChannel (Ptr<WifiChannel> channel)

 {

   m_channel = channel;

   if (m_channel != 0 && m_phy != 0)

     {

       m_channel->Add (this, m_phy);

       m_phy->SetChannel (m_channel);

     }

 }

 Ptr<WifiMac> 

 WifiNetDevice::GetMac (void) const

 {

   return m_mac;

 }

 Ptr<WifiPhy> 

 WifiNetDevice::GetPhy (void) const

 {

   return m_phy;

 }

 Ptr<WifiRemoteStationManager> 

 WifiNetDevice::GetRemoteStationManager (void) const

 {

   return m_stationManager;

 }

 void 

 WifiNetDevice::SetName(const std::string name)

 {

   m_name = name;

 }

 std::string 

 WifiNetDevice::GetName(void) const

 {

   return m_name;

 }

 void 

 WifiNetDevice::SetIfIndex(const uint32_t index)

 {

   m_ifIndex = index;

 }

 uint32_t 

 WifiNetDevice::GetIfIndex(void) const

 {

   return m_ifIndex;

 }

 Ptr<Channel> 

 WifiNetDevice::GetChannel (void) const

 {

   return m_channel;

 }

 Ptr<WifiChannel> 

 WifiNetDevice::DoGetChannel (void) const

 {

   return m_channel;

 }

 Address 

 WifiNetDevice::GetAddress (void) const

 {

   return m_mac->GetAddress ();

 }

 bool 

 WifiNetDevice::SetMtu (const uint16_t mtu)

 {

   UintegerValue maxMsduSize;

   m_mac->GetAttribute ("MaxMsduSize", maxMsduSize);

   if (mtu > maxMsduSize.Get () || mtu == 0)

     {

       return false;

     }

   m_mtu = mtu;

   return true;

 }

 uint16_t 

 WifiNetDevice::GetMtu (void) const

 {

   if (m_mtu == 0)

     {

       UintegerValue maxMsduSize;

       m_mac->GetAttribute ("MaxMsduSize", maxMsduSize);

       m_mtu = maxMsduSize.Get ();

     }

   return m_mtu;

 }

 bool 

 WifiNetDevice::IsLinkUp (void) const

 {

   return m_phy != 0 && m_linkUp;

 }

 void 

 WifiNetDevice::SetLinkChangeCallback (Callback<void> callback)

 {

   m_linkChange = callback;

 }

 bool 

 WifiNetDevice::IsBroadcast (void) const

 {

   return true;

 }

 Address 

 WifiNetDevice::GetBroadcast (void) const

 {

   return Mac48Address::GetBroadcast ();

 }

 bool 

 WifiNetDevice::IsMulticast (void) const

 {

   return false;

 }

 Address 

 WifiNetDevice::GetMulticast (Ipv4Address multicastGroup) const

 {

   return Mac48Address::GetMulticast (multicastGroup);

 }

 Address WifiNetDevice::GetMulticast (Ipv6Address addr) const

 {

   return Mac48Address::GetMulticast (addr);

 }

 bool 

 WifiNetDevice::IsPointToPoint (void) const

 {

   return false;

 }

 bool 

 WifiNetDevice::Send(Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)

 {

   NS_ASSERT (Mac48Address::IsMatchingType (dest));

   Mac48Address realTo = Mac48Address::ConvertFrom (dest);

   LlcSnapHeader llc;

   llc.SetType (protocolNumber);

   packet->AddHeader (llc);

   m_txLogger (packet, realTo);

   m_mac->Enqueue (packet, realTo);

   return true;

 }

 Ptr<Node> 

 WifiNetDevice::GetNode (void) const

 {

   return m_node;

 }

 void 

 WifiNetDevice::SetNode (Ptr<Node> node)

 {

   m_node = node;

 }

 bool 

 WifiNetDevice::NeedsArp (void) const

 {

   return true;

 }

 void 

 WifiNetDevice::SetReceiveCallback (NetDevice::ReceiveCallback cb)

 {

   m_forwardUp = cb;

 }

 void

 WifiNetDevice::ForwardUp (Ptr<Packet> packet, Mac48Address from, Mac48Address to)

 {

   m_rxLogger (packet, from);

   LlcSnapHeader llc;

   packet->RemoveHeader (llc);

   enum NetDevice::PacketType type;

   if (to.IsBroadcast ())

     {

       type = NetDevice::PACKET_BROADCAST;

     }

   else if (to.IsMulticast ())

     {

       type = NetDevice::PACKET_MULTICAST;

     }

   else if (to == m_mac->GetAddress ())

     {

       type = NetDevice::PACKET_HOST;

     }

   else

     {

       type = NetDevice::PACKET_OTHERHOST;

     }

   if (type != NetDevice::PACKET_OTHERHOST)

     {

       m_forwardUp (this, packet, llc.GetType (), from);

     }

   if (!m_promiscRx.IsNull ())

     {

       m_promiscRx (this, packet, llc.GetType (), from, to, type);

     }

 }

 void

 WifiNetDevice::LinkUp (void)

 {

   m_linkUp = true;

   if (!m_linkChange.IsNull ())

     {

       m_linkChange ();

     }

 }

 void

 WifiNetDevice::LinkDown (void)

 {

   m_linkUp = false;

   if (!m_linkChange.IsNull ())

     {

       m_linkChange ();

     }

 }

 bool

 WifiNetDevice::SendFrom (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber)

 {

   NS_ASSERT (Mac48Address::IsMatchingType (dest));

   NS_ASSERT (Mac48Address::IsMatchingType (source));

   Mac48Address realTo = Mac48Address::ConvertFrom (dest);

   Mac48Address realFrom = Mac48Address::ConvertFrom (source);

   LlcSnapHeader llc;

   llc.SetType (protocolNumber);

   packet->AddHeader (llc);

   m_txLogger (packet, realTo);

   m_mac->Enqueue (packet, realTo, realFrom);

   return true;

 }

 void

 WifiNetDevice::SetPromiscReceiveCallback (PromiscReceiveCallback cb)

 {

   m_promiscRx = cb;

 }

 bool

 WifiNetDevice::SupportsSendFrom (void) const

 {

   return m_mac->SupportsSendFrom ();

 }

 } // namespace ns3