satellite-llc.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013 Magister Solutions Ltd
 *
 * 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: Jani Puttonen <jani.puttonen@magister.fi>
 */
 
#ifndef SATELLITE_LLC_H_
#define SATELLITE_LLC_H_
 
#include "satellite-base-encapsulator.h"
 
#include <ns3/mac48-address.h>
#include <ns3/object.h>
#include <ns3/ptr.h>
#include <ns3/simple-ref-count.h>
#include <ns3/traced-callback.h>
 
#include <map>
#include <vector>
 
namespace ns3
{
 
class Time;
class Address;
class Packet;
class SatControlMessage;
class SatSchedulingObject;
class SatNodeInfo;
 
class EncapKey : public SimpleRefCount<EncapKey>
{
  public:
    Mac48Address m_encapAddress;
    Mac48Address m_decapAddress;
    Mac48Address m_sourceE2EAddress;
    Mac48Address m_destE2EAddress;
    int8_t m_flowId;
 
    EncapKey(const Mac48Address encapAddress,
             const Mac48Address decapAddress,
             const uint8_t flowId,
             const Mac48Address sourceE2EAddress = Mac48Address(),
             const Mac48Address destE2EAddress = Mac48Address())
        : m_encapAddress(encapAddress),
          m_decapAddress(decapAddress),
          m_sourceE2EAddress(sourceE2EAddress),
          m_destE2EAddress(destE2EAddress),
          m_flowId(flowId)
    {
    }
};
 
class EncapKeyCompare
{
  public:
    bool operator()(Ptr<EncapKey> key1, Ptr<EncapKey> key2) const
    {
        if (key1->m_encapAddress == key2->m_encapAddress)
        {
            if (key1->m_decapAddress == key2->m_decapAddress)
            {
                return key1->m_flowId < key2->m_flowId;
            }
            else
            {
                return key1->m_decapAddress < key2->m_decapAddress;
            }
        }
        else
        {
            return key1->m_encapAddress < key2->m_encapAddress;
        }
    }
};
 
class SatLlc : public Object
{
  public:
    static TypeId GetTypeId(void);
 
    SatLlc();
 
    SatLlc(SatEnums::RegenerationMode_t forwardLinkRegenerationMode,
           SatEnums::RegenerationMode_t returnLinkRegenerationMode);
 
    virtual ~SatLlc();
 
    typedef std::map<Ptr<EncapKey>, Ptr<SatBaseEncapsulator>, EncapKeyCompare> EncapContainer_t;
 
    typedef Callback<void, Ptr<const Packet>> ReceiveCallback;
 
    typedef Callback<Ptr<SatControlMessage>, uint32_t> ReadCtrlMsgCallback;
 
    void SetReadCtrlCallback(SatLlc::ReadCtrlMsgCallback cb);
 
    virtual bool Enque(Ptr<Packet> packet, Address dest, uint8_t flowId);
 
    virtual Ptr<Packet> NotifyTxOpportunity(uint32_t bytes,
                                            Mac48Address utAddr,
                                            uint8_t flowId,
                                            uint32_t& bytesLeft,
                                            uint32_t& nextMinTxO) = 0;
 
    virtual void Receive(Ptr<Packet> packet, Mac48Address source, Mac48Address dest);
 
    virtual void ReceiveHigherLayerPdu(Ptr<Packet> packet, Mac48Address source, Mac48Address dest);
 
    void SetReceiveCallback(SatLlc::ReceiveCallback cb);
 
    void AddEncap(Mac48Address source,
                  Mac48Address dest,
                  uint8_t flowId,
                  Ptr<SatBaseEncapsulator> enc);
 
    void AddDecap(Mac48Address source,
                  Mac48Address dest,
                  uint8_t flowId,
                  Ptr<SatBaseEncapsulator> dec);
 
    virtual void SetNodeInfo(Ptr<SatNodeInfo> nodeInfo);
 
    virtual void GetSchedulingContexts(std::vector<Ptr<SatSchedulingObject>>& output) const = 0;
 
    virtual bool BuffersEmpty() const;
 
    virtual bool ControlBuffersEmpty() const;
 
    virtual uint32_t GetNBytesInQueue(Mac48Address utAddress) const = 0;
 
    virtual uint32_t GetNPacketsInQueue(Mac48Address utAddress) const = 0;
 
    virtual uint32_t GetNBytesInQueue() const;
 
    virtual uint32_t GetNPacketsInQueue() const;
 
    void SetCtrlMsgCallback(SatBaseEncapsulator::SendCtrlCallback cb);
 
    virtual void SetGwAddress(Mac48Address address);
 
    virtual void SetSatelliteAddress(Mac48Address address);
 
    void SetAdditionalHeaderSize(uint32_t additionalHeaderSize);
 
  protected:
    virtual void DoDispose();
 
    virtual void CreateEncap(Ptr<EncapKey> key) = 0;
 
    virtual void CreateDecap(Ptr<EncapKey> key) = 0;
 
    virtual void ReceiveAck(Ptr<SatArqAckMessage> ack, Mac48Address source, Mac48Address dest);
 
    virtual SatEnums::SatLinkDir_t GetSatLinkTxDir();
 
    virtual SatEnums::SatLinkDir_t GetSatLinkRxDir();
 
    TracedCallback<Time,
                   SatEnums::SatPacketEvent_t,
                   SatEnums::SatNodeType_t,
                   uint32_t,
                   Mac48Address,
                   SatEnums::SatLogLevel_t,
                   SatEnums::SatLinkDir_t,
                   std::string>
        m_packetTrace;
 
    Ptr<SatNodeInfo> m_nodeInfo;
 
    EncapContainer_t m_encaps;
 
    EncapContainer_t m_decaps;
 
    bool m_fwdLinkArqEnabled;
 
    bool m_rtnLinkArqEnabled;
 
    Mac48Address m_gwAddress;
 
    Mac48Address m_satelliteAddress;
 
    uint32_t m_additionalHeaderSize;
 
    ReceiveCallback m_rxCallback;
 
    SatLlc::ReadCtrlMsgCallback m_readCtrlCallback;
 
    SatBaseEncapsulator::SendCtrlCallback m_sendCtrlCallback;
 
    SatEnums::RegenerationMode_t m_forwardLinkRegenerationMode;
 
    SatEnums::RegenerationMode_t m_returnLinkRegenerationMode;
};
 
} // namespace ns3
 
#endif /* SATELLITE_LLC_H_ */