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

/*

 * Copyright (c) 2008 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 "regular-wifi-mac.h"

#include "ns3/log.h"

#include "ns3/boolean.h"

#include "ns3/pointer.h"

#include "ns3/uinteger.h"

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

#include "mac-rx-middle.h"

#include "mac-tx-middle.h"

#include "mac-low.h"

#include "dcf.h"

#include "dcf-manager.h"

#include "wifi-phy.h"

#include "msdu-aggregator.h"

NS_LOG_COMPONENT_DEFINE ("RegularWifiMac");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (RegularWifiMac);

RegularWifiMac::RegularWifiMac ()

{

  NS_LOG_FUNCTION (this);

  m_rxMiddle = new MacRxMiddle ();

  m_rxMiddle->SetForwardCallback (MakeCallback (&RegularWifiMac::Receive, this));

  m_txMiddle = new MacTxMiddle ();

  m_low = CreateObject<MacLow> ();

  m_low->SetRxCallback (MakeCallback (&MacRxMiddle::Receive, m_rxMiddle));

  m_dcfManager = new DcfManager ();

  m_dcfManager->SetupLowListener (m_low);

  m_dca = CreateObject<DcaTxop> ();

  m_dca->SetLow (m_low);

  m_dca->SetManager (m_dcfManager);

  m_dca->SetTxOkCallback (MakeCallback (&RegularWifiMac::TxOk, this));

  m_dca->SetTxFailedCallback (MakeCallback (&RegularWifiMac::TxFailed, this));

  // Construct the EDCAFs. The ordering is important - highest

  // priority (see Table 9-1 in IEEE 802.11-2007) must be created

  // first.

  SetupEdcaQueue (AC_VO);

  SetupEdcaQueue (AC_VI);

  SetupEdcaQueue (AC_BE);

  SetupEdcaQueue (AC_BK);

}

RegularWifiMac::~RegularWifiMac ()

{

  NS_LOG_FUNCTION (this);

}

void

RegularWifiMac::DoInitialize ()

{

  NS_LOG_FUNCTION (this);

  m_dca->Initialize ();

  for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i)

    {

      i->second->Initialize ();

    }

}

void

RegularWifiMac::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  delete m_rxMiddle;

  m_rxMiddle = NULL;

  delete m_txMiddle;

  m_txMiddle = NULL;

  delete m_dcfManager;

  m_dcfManager = NULL;

  m_low->Dispose ();

  m_low = NULL;

  m_phy = NULL;

  m_stationManager = NULL;

  m_dca->Dispose ();

  m_dca = NULL;

  for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i)

    {

      i->second = NULL;

    }

}

void

RegularWifiMac::SetWifiRemoteStationManager (Ptr<WifiRemoteStationManager> stationManager)

{

  NS_LOG_FUNCTION (this << stationManager);

  m_stationManager = stationManager;

  m_low->SetWifiRemoteStationManager (stationManager);

  m_dca->SetWifiRemoteStationManager (stationManager);

  for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i)

    {

      i->second->SetWifiRemoteStationManager (stationManager);

    }

}

Ptr<WifiRemoteStationManager>

RegularWifiMac::GetWifiRemoteStationManager () const

{

  return m_stationManager;

}

void

RegularWifiMac::SetupEdcaQueue (enum AcIndex ac)

{

  NS_LOG_FUNCTION (this << ac);

  // Our caller shouldn't be attempting to setup a queue that is

  // already configured.

  NS_ASSERT (m_edca.find (ac) == m_edca.end ());

  Ptr<EdcaTxopN> edca = CreateObject<EdcaTxopN> ();

  edca->SetLow (m_low);

  edca->SetManager (m_dcfManager);

  edca->SetTxMiddle (m_txMiddle);

  edca->SetTxOkCallback (MakeCallback (&RegularWifiMac::TxOk, this));

  edca->SetTxFailedCallback (MakeCallback (&RegularWifiMac::TxFailed, this));

  edca->SetAccessCategory (ac);

  edca->CompleteConfig ();

  m_edca.insert (std::make_pair (ac, edca));

}

void

RegularWifiMac::SetTypeOfStation (TypeOfStation type)

{

  NS_LOG_FUNCTION (this << type);

  for (EdcaQueues::iterator i = m_edca.begin (); i != m_edca.end (); ++i)

    {

      i->second->SetTypeOfStation (type);

    }

}

Ptr<DcaTxop>

RegularWifiMac::GetDcaTxop () const

{

  return m_dca;

}

Ptr<EdcaTxopN>

RegularWifiMac::GetVOQueue () const

{

  return m_edca.find (AC_VO)->second;

}

Ptr<EdcaTxopN>

RegularWifiMac::GetVIQueue () const

{

  return m_edca.find (AC_VI)->second;

}

Ptr<EdcaTxopN>

RegularWifiMac::GetBEQueue () const

{

  return m_edca.find (AC_BE)->second;

}

Ptr<EdcaTxopN>

RegularWifiMac::GetBKQueue () const

{

  return m_edca.find (AC_BK)->second;

}

void

RegularWifiMac::SetWifiPhy (Ptr<WifiPhy> phy)

{

  NS_LOG_FUNCTION (this << phy);

  m_phy = phy;

  m_dcfManager->SetupPhyListener (phy);

  m_low->SetPhy (phy);

}

Ptr<WifiPhy>

RegularWifiMac::GetWifiPhy () const

{

  return m_phy;

}

void

RegularWifiMac::SetForwardUpCallback (ForwardUpCallback upCallback)

{

  NS_LOG_FUNCTION (this);

  m_forwardUp = upCallback;

}

void

RegularWifiMac::SetLinkUpCallback (Callback<void> linkUp)

{

  NS_LOG_FUNCTION (this);

  m_linkUp = linkUp;

}

void

RegularWifiMac::SetLinkDownCallback (Callback<void> linkDown)

{

  NS_LOG_FUNCTION (this);

  m_linkDown = linkDown;

}

void

RegularWifiMac::SetQosSupported (bool enable)

{

  NS_LOG_FUNCTION (this);

  m_qosSupported = enable;

}

bool

RegularWifiMac::GetQosSupported () const

{

  return m_qosSupported;

}

void

RegularWifiMac::SetSlot (Time slotTime)

{

  NS_LOG_FUNCTION (this << slotTime);

  m_dcfManager->SetSlot (slotTime);

  m_low->SetSlotTime (slotTime);

}

Time

RegularWifiMac::GetSlot (void) const

{

  return m_low->GetSlotTime ();

}

void

RegularWifiMac::SetSifs (Time sifs)

{

  NS_LOG_FUNCTION (this << sifs);

  m_dcfManager->SetSifs (sifs);

  m_low->SetSifs (sifs);

}

Time

RegularWifiMac::GetSifs (void) const

{

  return m_low->GetSifs ();

}

void

RegularWifiMac::SetEifsNoDifs (Time eifsNoDifs)

{

  NS_LOG_FUNCTION (this << eifsNoDifs);

  m_dcfManager->SetEifsNoDifs (eifsNoDifs);

}

Time

RegularWifiMac::GetEifsNoDifs (void) const

{

  return m_dcfManager->GetEifsNoDifs ();

}

void

RegularWifiMac::SetPifs (Time pifs)

{

  NS_LOG_FUNCTION (this << pifs);

  m_low->SetPifs (pifs);

}

Time

RegularWifiMac::GetPifs (void) const

{

  return m_low->GetPifs ();

}

void

RegularWifiMac::SetAckTimeout (Time ackTimeout)

{

  NS_LOG_FUNCTION (this << ackTimeout);

  m_low->SetAckTimeout (ackTimeout);

}

Time

RegularWifiMac::GetAckTimeout (void) const

{

  return m_low->GetAckTimeout ();

}

void

RegularWifiMac::SetCtsTimeout (Time ctsTimeout)

{

  NS_LOG_FUNCTION (this << ctsTimeout);

  m_low->SetCtsTimeout (ctsTimeout);

}

Time

RegularWifiMac::GetCtsTimeout (void) const

{

  return m_low->GetCtsTimeout ();

}

void

RegularWifiMac::SetBasicBlockAckTimeout (Time blockAckTimeout)

{

  NS_LOG_FUNCTION (this << blockAckTimeout);

  m_low->SetBasicBlockAckTimeout (blockAckTimeout);

}

Time

RegularWifiMac::GetBasicBlockAckTimeout (void) const

{

  return m_low->GetBasicBlockAckTimeout ();

}

void

RegularWifiMac::SetCompressedBlockAckTimeout (Time blockAckTimeout)

{

  NS_LOG_FUNCTION (this << blockAckTimeout);

  m_low->SetCompressedBlockAckTimeout (blockAckTimeout);

}

Time

RegularWifiMac::GetCompressedBlockAckTimeout (void) const

{

  return m_low->GetCompressedBlockAckTimeout ();

}

void

RegularWifiMac::SetAddress (Mac48Address address)

{

  NS_LOG_FUNCTION (this << address);

  m_low->SetAddress (address);

}

Mac48Address

RegularWifiMac::GetAddress (void) const

{

  return m_low->GetAddress ();

}

void

RegularWifiMac::SetSsid (Ssid ssid)

{

  NS_LOG_FUNCTION (this << ssid);

  m_ssid = ssid;

}

Ssid

RegularWifiMac::GetSsid (void) const

{

  return m_ssid;

}

void

RegularWifiMac::SetBssid (Mac48Address bssid)

{

  NS_LOG_FUNCTION (this << bssid);

  m_low->SetBssid (bssid);

}

Mac48Address

RegularWifiMac::GetBssid (void) const

{

  return m_low->GetBssid ();

}

void

RegularWifiMac::SetPromisc (void)

{

  m_low->SetPromisc ();

}

void

RegularWifiMac::Enqueue (Ptr<const Packet> packet,

                         Mac48Address to, Mac48Address from)

{

  // We expect RegularWifiMac subclasses which do support forwarding (e.g.,

  // AP) to override this method. Therefore, we throw a fatal error if

  // someone tries to invoke this method on a class which has not done

  // this.

  NS_FATAL_ERROR ("This MAC entity (" << this << ", " << GetAddress ()

                                      << ") does not support Enqueue() with from address");

}

bool

RegularWifiMac::SupportsSendFrom (void) const

{

  return false;

}

void

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

{

  NS_LOG_FUNCTION (this << packet << from);

  m_forwardUp (packet, from, to);

}

void

RegularWifiMac::Receive (Ptr<Packet> packet, const WifiMacHeader *hdr)

{

  NS_LOG_FUNCTION (this << packet << hdr);

  Mac48Address to = hdr->GetAddr1 ();

  Mac48Address from = hdr->GetAddr2 ();

  // We don't know how to deal with any frame that is not addressed to

  // us (and odds are there is nothing sensible we could do anyway),

  // so we ignore such frames.

  //

  // The derived class may also do some such filtering, but it doesn't

  // hurt to have it here too as a backstop.

  if (to != GetAddress ())

    {

      return;

    }

  if (hdr->IsMgt () && hdr->IsAction ())

    {

      // There is currently only any reason for Management Action

      // frames to be flying about if we are a QoS STA.

      NS_ASSERT (m_qosSupported);

      WifiActionHeader actionHdr;

      packet->RemoveHeader (actionHdr);

      switch (actionHdr.GetCategory ())

        {

        case WifiActionHeader::BLOCK_ACK:

          switch (actionHdr.GetAction ().blockAck)

            {

            case WifiActionHeader::BLOCK_ACK_ADDBA_REQUEST:

              {

                MgtAddBaRequestHeader reqHdr;

                packet->RemoveHeader (reqHdr);

                // We've received an ADDBA Request. Our policy here is

                // to automatically accept it, so we get the ADDBA

                // Response on it's way immediately.

                SendAddBaResponse (&reqHdr, from);

                // This frame is now completely dealt with, so we're done.

                return;

              }

            case WifiActionHeader::BLOCK_ACK_ADDBA_RESPONSE:

              {

                MgtAddBaResponseHeader respHdr;

                packet->RemoveHeader (respHdr);

                // We've received an ADDBA Response. We assume that it

                // indicates success after an ADDBA Request we have

                // sent (we could, in principle, check this, but it

                // seems a waste given the level of the current model)

                // and act by locally establishing the agreement on

                // the appropriate queue.

                AcIndex ac = QosUtilsMapTidToAc (respHdr.GetTid ());

                m_edca[ac]->GotAddBaResponse (&respHdr, from);

                // This frame is now completely dealt with, so we're done.

                return;

              }