app-key-stream.h

Go to the documentation of this file.

/*
 * Copyright(c) 2020 DOTFEESA www.tk.etf.unsa.ba
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 *
 *
 * Author:  Emir Dervisevic <emir.dervisevic@etf.unsa.ba>
 *          Miralem Mehic <miralem.mehic@ieee.org>
 */
#ifndef KEY_STREAM_H
#define KEY_STREAM_H
 
#include <stdint.h>
#include <algorithm>
#include <stdint.h>
#include <string.h>
 
#include "ns3/packet.h"
#include "ns3/object.h"
#include "ns3/callback.h"
#include "ns3/assert.h"
#include "ns3/ptr.h"
#include "ns3/simulator.h"
#include "ns3/nstime.h"
#include "ns3/traced-callback.h"
#include "ns3/deprecated.h"
#include "qkd-key.h"
#include "app-key.h"
 
 
namespace ns3 {
 
/**
 * @ingroup qkd
 * @brief key stream session
 */
    class KeyStreamSession : public Object {
        public:
 
            enum Type
            {
                EMPTY,
                ENCRYPTION,
                AUTHENTICATION
            };
 
            KeyStreamSession() : m_id(""), m_type(Type::ENCRYPTION), m_size(0), m_verified(false), m_stream({}) {}
 
            void SetId(std::string ksid) {
                m_id = ksid;
            }
 
            std::string GetId() const {
                return m_id;
            }
 
            void SetVerified(bool isVerified) {
                m_verified = isVerified;
            }
 
            bool IsVerified() const {
                return m_verified;
            }
 
            void AddKey(Ptr<AppKey> key) {
                m_stream.insert(std::make_pair(key->GetIndex(), key));
            }
 
            Ptr<AppKey> GetKey(uint32_t packetSize = 0) {
                Ptr<AppKey> key;
                auto it {m_stream.begin()};
                if(it != m_stream.end()) {
                    key = it->second;
                    if(GetType() == ENCRYPTION){
                        it->second->UseLifetime(packetSize);
                        if(it->second->GetLifetime() == 0)
                            m_stream.erase(it);
                    }else{
                        m_stream.erase(it);
                    }
                }
 
                return key;
            }
 
            uint32_t GetKeyCount() const {
                return m_stream.size();
            }
 
            void SetSize(uint32_t size) {
                m_size = size;
            }
 
            uint32_t GetSize() const {
                return m_size;
            }
 
            bool SyncStream(uint32_t index) {
                auto it = m_stream.find(index);
                bool inSync {m_stream.begin() == it};
                if(it != m_stream.end()){
                    while(m_stream.begin() != it)
                        m_stream.erase(m_stream.begin());
                }
 
                return inSync;
            }
 
            void SetType(Type type) {
                m_type = type;
            }
 
            Type GetType() const {
                return m_type;
            }
 
            void ClearStream() {
                m_id.clear();
                m_stream.clear();
                m_verified = false;
            }
 
 
        private:
 
            std::string m_id;
            Type        m_type;                         //<!Session type
            uint32_t    m_size;                         //<!Key stream size at the application layer
            bool        m_verified;                     //<!Is verified
            std::map<uint32_t, Ptr<AppKey> > m_stream;    //<!Key streamW
 
    };
 
} // namespace ns3
 
#endif /* KEY_STREAM_H */