GlobalNodeList.h

Go to the documentation of this file.

//
// Copyright (C) 2006 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// 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.
//

#ifndef __GLOBALNODELIST_H__
#define __GLOBALNODELIST_H__

#include <map>
#include <vector>
#include <oversim_mapset.h>

#include <omnetpp.h>

#include <ChurnGenerator.h>

#include <BinaryValue.h>
#include <NodeHandle.h>
#include <PeerStorage.h>

class BootstrapList;
class TransportAddress;
class OverlayKey;
class GlobalStatistics;


class GlobalNodeList : public cSimpleModule
{
public:
    typedef std::vector<OverlayKey> KeyList;

    void addPeer(const IPvXAddress& ip, PeerInfo* info);

    void sendNotificationToAllPeers(int category);

    virtual void killPeer(const IPvXAddress& ip);

    virtual const NodeHandle& getRandomNode(int32_t overlayId = -1,
                                            int32_t nodeType = -1,
                                            bool bootstrappedNeeded = true,
                                            bool inoffensiveNeeded = false);

    virtual const NodeHandle& getBootstrapNode(int32_t overlayId = -1,
                                               const NodeHandle &node =
                                               NodeHandle::UNSPECIFIED_NODE);

    virtual void registerPeer(const NodeHandle& peer,
                              int32_t overlayId = 0);


    virtual void refreshEntry(const TransportAddress& peer,
                              int32_t overlayId = 0);

    virtual void removePeer(const TransportAddress& peer,
                            int32_t overlayId = 0);

    virtual KeyList* getKeyList(uint32_t maximumKeys);

    virtual const OverlayKey& getRandomKeyListItem();

    virtual void setOverlayReadyIcon(const TransportAddress& address, bool ready);

    virtual PeerInfo* getPeerInfo(const TransportAddress& peer);

    virtual void setMalicious(const TransportAddress& address, bool malicious);

    virtual bool isMalicious(const TransportAddress& address);

    virtual cObject** getContext(const TransportAddress& address);

    void setPreKilled(const TransportAddress& address);

     TransportAddress* getRandomAliveNode(int32_t overlayId = -1,
                                          int32_t nodeType = -1);

    virtual PeerInfo* getRandomPeerInfo(int32_t overlayId = -1,
                                        int32_t nodeType = -1,
                                        bool bootstrapNeeded = false);

    virtual PeerInfo* getPeerInfo(const IPvXAddress& ip);

    size_t getNumNodes() { return peerStorage.size(); };

    bool areNodeTypesConnected(int32_t a, int32_t b);
    void connectNodeTypes(int32_t a, int32_t b);
    void disconnectNodeTypes(int32_t a, int32_t b);
    void mergeBootstrapNodes(int toPartition, int fromPartition, int numNodes);

    inline void incLandmarkPeerSize() { landmarkPeerSize++; }
    inline uint16_t getLandmarkPeerSize() { return landmarkPeerSize; }
    inline void incLandmarkPeerSizePerType(uint16_t type) { landmarkPeerSizePerType[type]++; }

    std::vector<IPvXAddress>* getAllIps();
    NodeHandle* getNodeHandle(const IPvXAddress& address);

protected:
    virtual void initialize();

    virtual void handleMessage(cMessage* msg);

    virtual void createKeyList(uint32_t size);

    KeyList keyList; 
    uint16_t landmarkPeerSize;
    uint16_t landmarkPeerSizePerType[MAX_NODETYPES];
    uint32_t preKilledNodes; 
    double maliciousNodeRatio; 
    cOutVector maliciousNodesVector; 
    PeerStorage peerStorage; 
    // key distribution parameters TODO should be put into an other module
    uint32_t maxNumberOfKeys; 
    double keyProbability; 
    bool isKeyListInitialized;

private:
    GlobalStatistics* globalStatistics; 
    bool connectionMatrix[MAX_NODETYPES][MAX_NODETYPES]; 
};

#endif