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 <stdint.h>
#include <string>
#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();

    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_ */