LinkTable.cpp

#include "LinkTable.h"

namespace forest {

LinkTable::LinkTable(int maxLnk1) : maxLnk(maxLnk1) {
                map = new HashMap<uint64_t,Entry,Hash::u64>(maxLnk,false);
                padrMap = new HashSet<fAdr_t,Hash::s32>(maxLnk,false);
};
                
LinkTable::~LinkTable() {
                delete map; delete padrMap;
}

int LinkTable::addEntry(int lnk, ipa_t peerIp, ipp_t peerPort, uint64_t nonce) {
                Entry e;
                e.iface= 0; e.isConnected = false; e.nonce = nonce;
                e.peerIp = peerIp; e.peerPort = peerPort;
                e.peerAdr = 0; e.peerType = Forest::UNDEF_NODE;
                e.rates.set(Forest::MINBITRATE,Forest::MINBITRATE,
                                    Forest::MINPKTRATE,Forest::MINPKTRATE);
                e.availRates.set(Forest::MINBITRATE,Forest::MINBITRATE,
                                                 Forest::MINPKTRATE,Forest::MINPKTRATE);

                if (lnk == 0) lnk = map->put(nonce,e);
                else lnk = map->put(nonce,e,lnk);
        return lnk;
}

bool LinkTable::connect(int lnk, ipa_t peerIp, ipp_t peerPort) {
                if (!valid(lnk)) return false;
                Entry& e = getEntry(lnk);
                if (e.isConnected == true) return false; // already connected
                if (map->find(e.nonce) != lnk) return false;
                if (!map->rekey(lnk, hashkey(peerIp,peerPort))) return false;
                e.peerIp = peerIp; e.peerPort = peerPort; e.isConnected = true;
        return true;
}

bool LinkTable::removeEntry(int lnk) {
                if (!valid(lnk)) return false;
                Entry& e = getEntry(lnk);
                if (e.isConnected == true)
                                map->remove(hashkey(e.peerIp,e.peerPort));
                else
                                map->remove(e.nonce);
                return true;
}

void LinkTable::setPeerAdr(int lnk, fAdr_t adr) {
                if (!valid(lnk)) return;
                Entry& e = getEntry(lnk);

                if (e.peerAdr != 0) padrMap->remove(e.peerAdr);
                if (adr != 0) padrMap->insert(adr,lnk);
                e.peerAdr = adr;
}

bool LinkTable::checkEntry(int lnk) {
                if (!valid(lnk)) return false;
                Entry& e = getEntry(lnk);
                // the forest address of every peer must be a valid unicast address
                if (!Forest::validUcastAdr(e.peerAdr)) return false;

                // only a router may use the forest port number
                if (e.peerPort == Forest::ROUTER_PORT && e.peerType != Forest::ROUTER)
                return false;
                return true;
}

int LinkTable::readEntry(istream& in) {
                int lnk, iface; RateSpec rs;
                ipa_t peerIp; int peerPort;
                Forest::ntyp_t peerType; int peerAdr;
                string typStr;

                Util::skipBlank(in);
                if ( !Util::readInt(in,lnk) ||
                     !Util::readInt(in,iface) ||
                     !Np4d::readIpAdr(in,peerIp) || !Util::verify(in,':') ||
             !Util::readInt(in,peerPort) ||
                     !Util::readWord(in,typStr) ||
                     !Forest::readForestAdr(in,peerAdr) ||
                     !rs.read(in)) {
                                return 0;
                }
                Util::nextLine(in);

                peerType = Forest::getNodeType(typStr);
                if (peerType == Forest::UNDEF_NODE) return 0;

                if (!addEntry(lnk,peerIp,peerPort,0)) return 0;
                Entry& e = getEntry(lnk);
                e.iface = iface; 
        e.peerType = (Forest::ntyp_t) peerType;
                e.peerAdr = peerAdr;
                e.rates = rs; e.availRates = rs;

                if (!checkEntry(lnk)) { removeEntry(lnk); return 0; }

                return lnk;
}

bool LinkTable::read(istream& in) {
                int num;
                Util::skipBlank(in);
        if (!Util::readInt(in,num)) return false;
        Util::nextLine(in);
                for (int i = 1; i <= num; i++) {
                                if (readEntry(in) == 0) {
                                                cerr << "LinkTable::read: could not read "
                                                     << i << "-th table entry" << endl;
                                                return false;
                                }
                }
                return true;
}

string LinkTable::link2string(int lnk) const {
                if (!valid(lnk)) { return ""; }
                stringstream ss;
                ss << setw(5) << right << lnk;
                ss << getEntry(lnk);
                return ss.str();
}

string LinkTable::toString() const {
                stringstream ss;
                ss << map->size() << endl;
                ss << "# link  iface    peerIp:port     peerType  peerAdr   ";
        ss << "  rates      avail rates      comtree count\n";
                for (int i = firstLink(); i != 0; i = nextLink(i)) 
                                ss << link2string(i) << endl;
                return ss.str();
}

/*
#define pack8(x)  (*buf = *((char*)  x), buf += 1)
#define pack16(x) (*buf = *((char*) htons(x)), buf += sizeof(uint16_t))
#define pack32(x) (*buf = *((char*) htonl(x)), buf += sizeof(uint32_t))
#define pack64(x) ( pack32(((x)>>32)&0xffffffff), pack32((x)&0xffffffff))
#define packRspec(x) (          pack32(x.bitRateUp), pack32(x.bitRateDown), \
                                pack32(x.pktRateUp), pack32(x.pktRateDown) )
*/

/*
#define unpack8(x) (x = *buf, buf += 1)
#define unpack16(x) (x = ntohs(*((uint16_t*) buf)), buf += sizeof(uint16_t))
#define unpack32(x) (x = ntohl(*((uint32_t*) buf)), buf += sizeof(uint32_t))
#define unpack64(x) (x  = ntohl(*((uint32_t*) buf)), buf += sizeof(uint32_t), \
                                     x |= ntohl(*((uint32_t*) buf)), buf += sizeof(uint32_t))
#define unpackRspec(x) (pack32(x.bitRateUp), pack32(x.bitRateDown), \
                                pack32(x.pktRateUp), pack32(x.pktRateDown) )
 */

} // ends namespace