diff --git a/src/bitdht/bdhash.cc b/src/bitdht/bdhash.cc index 831b8c5..762ca5e 100644 --- a/src/bitdht/bdhash.cc +++ b/src/bitdht/bdhash.cc @@ -277,3 +277,11 @@ int bdHashSpace::cleanHashSpace(bdNodeId *min, bdNodeId *max, time_t maxAge) return 1; } + +int bdHashSpace::clear() +{ + mHashTable.clear(); + return 1; +} + + diff --git a/src/bitdht/bdhash.h b/src/bitdht/bdhash.h index 4bf8dcd..10c8fd6 100644 --- a/src/bitdht/bdhash.h +++ b/src/bitdht/bdhash.h @@ -76,6 +76,7 @@ int modify(bdNodeId *id, std::string key, bdHashEntry *entry, uint32_t modFlags int printHashSpace(std::ostream&); int cleanHashSpace(bdNodeId *min, bdNodeId *max, time_t maxAge); +int clear(); private: diff --git a/src/bitdht/bdiface.h b/src/bitdht/bdiface.h index 08f3fb6..58e5365 100644 --- a/src/bitdht/bdiface.h +++ b/src/bitdht/bdiface.h @@ -176,6 +176,12 @@ virtual void removeCallback(BitDhtCallback *cb) = 0; virtual int getDhtPeerAddress(const bdNodeId *id, struct sockaddr_in &from) = 0; virtual int getDhtValue(const bdNodeId *id, std::string key, std::string &value) = 0; + /* stats and Dht state */ +virtual int startDht() = 0; +virtual int stopDht() = 0; +virtual int stateDht() = 0; /* STOPPED, STARTING, ACTIVE, FAILED */ +virtual uint32_t statsNetworkSize() = 0; +virtual uint32_t statsBDVersionSize() = 0; /* same version as us! */ }; #endif diff --git a/src/bitdht/bdmanager.cc b/src/bitdht/bdmanager.cc index 318474e..495de78 100644 --- a/src/bitdht/bdmanager.cc +++ b/src/bitdht/bdmanager.cc @@ -54,13 +54,17 @@ * #define DEBUG_MGR_PKT 1 ***/ + bdNodeManager::bdNodeManager(bdNodeId *id, std::string dhtVersion, std::string bootfile, bdDhtFunctions *fns) :bdNode(id, dhtVersion, bootfile, fns) { - mMode = BITDHT_MGR_STATE_STARTUP; + mMode = BITDHT_MGR_STATE_OFF; mFns = fns; mModeTS = 0 ; + mNetworkSize = 0; + mBdNetworkSize = 0; + /* setup a query for self */ #ifdef DEBUG_MGR std::cerr << "bdNodeManager::bdNodeManager() ID: "; @@ -69,6 +73,57 @@ bdNodeManager::bdNodeManager(bdNodeId *id, std::string dhtVersion, std::string b #endif } +int bdNodeManager::stopDht() +{ + time_t now = time(NULL); + + /* clean up node */ + shutdownNode(); + + /* flag queries as inactive */ + /* check if exists already */ + std::map::iterator it; + for(it = mActivePeers.begin(); it != mActivePeers.end(); it++) + { + it->second.mStatus = BITDHT_QUERY_READY; + } + + /* set state flag */ + mMode = BITDHT_MGR_STATE_OFF; + mModeTS = now; + + return 1; +} + +int bdNodeManager::startDht() +{ + time_t now = time(NULL); + + /* set startup mode */ + restartNode(); + + mMode = BITDHT_MGR_STATE_STARTUP; + mModeTS = now; + + return 1; +} + + /* STOPPED, STARTING, ACTIVE, FAILED */ +int bdNodeManager::stateDht() +{ + return mMode; +} + +uint32_t bdNodeManager::statsNetworkSize() +{ + return mNetworkSize; +} + +/* same version as us! */ +uint32_t bdNodeManager::statsBDVersionSize() +{ + return mBdNetworkSize; +} void bdNodeManager::addFindNode(bdNodeId *id, uint32_t qflags) @@ -166,6 +221,15 @@ void bdNodeManager::iteration() time_t modeAge = now - mModeTS; switch(mMode) { + case BITDHT_MGR_STATE_OFF: + { +#ifdef DEBUG_MGR + std::cerr << "bdNodeManager::iteration(): OFF"; + std::cerr << std::endl; +#endif + } + break; + case BITDHT_MGR_STATE_STARTUP: /* 10 seconds startup .... then switch to ACTIVE */ @@ -189,17 +253,26 @@ void bdNodeManager::iteration() #define MAX_FINDSELF_TIME 60 #define MIN_OP_SPACE_SIZE 100 + { + uint32_t nodeSpaceSize = mNodeSpace.calcSpaceSize(); + #ifdef DEBUG_MGR - std::cerr << "bdNodeManager::iteration() Finding Oneself: NodeSpace Size:" << mNodeSpace.size(); + std::cerr << "bdNodeManager::iteration() Finding Oneself: "; + std::cerr << "NodeSpace Size:" << nodeSpaceSize; std::cerr << std::endl; #endif - if ((modeAge > MAX_FINDSELF_TIME) || - (mNodeSpace.size() > MIN_OP_SPACE_SIZE)) - { - //mMode = BITDHT_MGR_STATE_ACTIVE; - mMode = BITDHT_MGR_STATE_REFRESH; - mModeTS = now; + if (nodeSpaceSize > MIN_OP_SPACE_SIZE) + { + mMode = BITDHT_MGR_STATE_REFRESH; + mModeTS = now; + } + + if (modeAge > MAX_FINDSELF_TIME) + { + mMode = BITDHT_MGR_STATE_FAILED; + mModeTS = now; + } } break; @@ -253,15 +326,37 @@ void bdNodeManager::iteration() case BITDHT_MGR_STATE_QUIET: { +#ifdef DEBUG_MGR + std::cerr << "bdNodeManager::iteration(): QUIET"; + std::cerr << std::endl; +#endif } break; + + default: + case BITDHT_MGR_STATE_FAILED: + { +#ifdef DEBUG_MGR + std::cerr << "bdNodeManager::iteration(): FAILED ==> STARTUP"; + std::cerr << std::endl; +#endif + stopDht(); + startDht(); + } + break; } - - /* tick parent */ - bdNode::iteration(); + if (mMode == BITDHT_MGR_STATE_OFF) + { + bdNode::iterationOff(); + } + else + { + /* tick parent */ + bdNode::iteration(); + } } @@ -271,6 +366,11 @@ int bdNodeManager::status() printState(); checkStatus(); + + /* update the network numbers */ + mNetworkSize = mNodeSpace.calcNetworkSize(); + mBdNetworkSize = mNodeSpace.calcNetworkSizeWithFlag( + BITDHT_PEER_STATUS_DHT_APPL); return 1; diff --git a/src/bitdht/bdmanager.h b/src/bitdht/bdmanager.h index 641877b..0b9a458 100644 --- a/src/bitdht/bdmanager.h +++ b/src/bitdht/bdmanager.h @@ -70,11 +70,13 @@ class bdQueryPeer }; +#define BITDHT_MGR_STATE_OFF 0 #define BITDHT_MGR_STATE_STARTUP 1 #define BITDHT_MGR_STATE_FINDSELF 2 #define BITDHT_MGR_STATE_ACTIVE 3 #define BITDHT_MGR_STATE_REFRESH 4 #define BITDHT_MGR_STATE_QUIET 5 +#define BITDHT_MGR_STATE_FAILED 6 #define MAX_STARTUP_TIME 10 #define MAX_REFRESH_TIME 10 @@ -112,6 +114,12 @@ virtual void removeCallback(BitDhtCallback *cb); virtual int getDhtPeerAddress(const bdNodeId *id, struct sockaddr_in &from); virtual int getDhtValue(const bdNodeId *id, std::string key, std::string &value); + /* stats and Dht state */ +virtual int startDht(); +virtual int stopDht(); +virtual int stateDht(); /* STOPPED, STARTING, ACTIVE, FAILED */ +virtual uint32_t statsNetworkSize(); +virtual uint32_t statsBDVersionSize(); /* same version as us! */ /******************* Internals *************************/ // Overloaded from bdnode for external node callback. @@ -140,6 +148,9 @@ void startQueries(); bdDhtFunctions *mFns; + uint32_t mNetworkSize; + uint32_t mBdNetworkSize; + /* future node functions */ //addPeerPing(foundId); //clearPing(it->first); diff --git a/src/bitdht/bdnode.cc b/src/bitdht/bdnode.cc index 33fd5e1..b6331dd 100644 --- a/src/bitdht/bdnode.cc +++ b/src/bitdht/bdnode.cc @@ -61,41 +61,7 @@ bdNode::bdNode(bdNodeId *ownId, std::string dhtVersion, std::string bootfile, bdDhtFunctions *fns) :mOwnId(*ownId), mNodeSpace(ownId, fns), mStore(bootfile, fns), mDhtVersion(dhtVersion), mFns(fns) { - /* setup */ - bdPeer peer; - while(mStore.getPeer(&peer)) - { - addPotentialPeer(&(peer.mPeerId)); - } - mCounterOutOfDatePing = 0; - mCounterPings = 0; - mCounterPongs = 0; - mCounterQueryNode = 0; - mCounterQueryHash = 0; - mCounterReplyFindNode = 0; - mCounterReplyQueryHash = 0; - - mCounterRecvPing = 0; - mCounterRecvPong = 0; - mCounterRecvQueryNode = 0; - mCounterRecvQueryHash = 0; - mCounterRecvReplyFindNode = 0; - mCounterRecvReplyQueryHash = 0; - - mLpfOutOfDatePing = 0; - mLpfPings = 0; - mLpfPongs = 0; - mLpfQueryNode = 0; - mLpfQueryHash = 0; - mLpfReplyFindNode = 0; - mLpfReplyQueryHash = 0; - - mLpfRecvPing = 0; - mLpfRecvPong = 0; - mLpfRecvQueryNode = 0; - mLpfRecvQueryHash = 0; - mLpfRecvReplyFindNode = 0; - mLpfRecvReplyQueryHash = 0; + resetStats(); } void bdNode::getOwnId(bdNodeId *id) @@ -103,19 +69,47 @@ void bdNode::getOwnId(bdNodeId *id) *id = mOwnId; } - - -#if 0 -void bdNode::run() +/***** Startup / Shutdown ******/ +void bdNode::restartNode() { + resetStats(); + + mStore.reloadFromStore(); + /* setup */ - while(1) + bdPeer peer; + while(mStore.getPeer(&peer)) { - iteration(); - sleep(1); + addPotentialPeer(&(peer.mPeerId)); } } -#endif + + +void bdNode::shutdownNode() +{ + /* clear the queries */ + mLocalQueries.clear(); + mRemoteQueries.clear(); + + /* clear the space */ + mNodeSpace.clear(); + mHashSpace.clear(); + + /* clear other stuff */ + mPotentialPeers.clear(); + mStore.clear(); + + /* clean up any outgoing messages */ + while(mOutgoingMsgs.size() > 0) + { + bdNodeNetMsg *msg = mOutgoingMsgs.front(); + mOutgoingMsgs.pop_front(); + + /* cleanup message */ + delete msg; + } +} + /* Crappy initial store... use bdspace as answer */ void bdNode::updateStore() @@ -156,6 +150,20 @@ void bdNode::printQueries() } } + +void bdNode::iterationOff() +{ + /* clean up any incoming messages */ + while(mIncomingMsgs.size() > 0) + { + bdNodeNetMsg *msg = mIncomingMsgs.front(); + mIncomingMsgs.pop_front(); + + /* cleanup message */ + delete msg; + } +} + void bdNode::iteration() { #ifdef DEBUG_NODE_MULTIPEER @@ -313,14 +321,6 @@ void bdNode::doStats() mLpfReplyQueryHash *= (LPF_FACTOR); mLpfReplyQueryHash += (1.0 - LPF_FACTOR) * mCounterReplyQueryHash; - mCounterOutOfDatePing = 0; - mCounterPings = 0; - mCounterPongs = 0; - mCounterQueryNode = 0; - mCounterQueryHash = 0; - mCounterReplyFindNode = 0; - mCounterReplyQueryHash = 0; - mLpfRecvPing *= (LPF_FACTOR); mLpfRecvPing += (1.0 - LPF_FACTOR) * mCounterRecvPing; mLpfRecvPong *= (LPF_FACTOR); @@ -334,12 +334,8 @@ void bdNode::doStats() mLpfRecvReplyQueryHash *= (LPF_FACTOR); mLpfRecvReplyQueryHash += (1.0 - LPF_FACTOR) * mCounterRecvReplyQueryHash; - mCounterRecvPing = 0; - mCounterRecvPong = 0; - mCounterRecvQueryNode = 0; - mCounterRecvQueryHash = 0; - mCounterRecvReplyFindNode = 0; - mCounterRecvReplyQueryHash = 0; + + resetCounters(); } void bdNode::printStats(std::ostream &out) @@ -370,8 +366,43 @@ void bdNode::printStats(std::ostream &out) out << std::endl; } +void bdNode::resetCounters() +{ + mCounterOutOfDatePing = 0; + mCounterPings = 0; + mCounterPongs = 0; + mCounterQueryNode = 0; + mCounterQueryHash = 0; + mCounterReplyFindNode = 0; + mCounterReplyQueryHash = 0; + mCounterRecvPing = 0; + mCounterRecvPong = 0; + mCounterRecvQueryNode = 0; + mCounterRecvQueryHash = 0; + mCounterRecvReplyFindNode = 0; + mCounterRecvReplyQueryHash = 0; +} +void bdNode::resetStats() +{ + mLpfOutOfDatePing = 0; + mLpfPings = 0; + mLpfPongs = 0; + mLpfQueryNode = 0; + mLpfQueryHash = 0; + mLpfReplyFindNode = 0; + mLpfReplyQueryHash = 0; + + mLpfRecvPing = 0; + mLpfRecvPong = 0; + mLpfRecvQueryNode = 0; + mLpfRecvQueryHash = 0; + mLpfRecvReplyFindNode = 0; + mLpfRecvReplyQueryHash = 0; + + resetCounters(); +} void bdNode::checkPotentialPeer(bdId *id) @@ -694,7 +725,7 @@ void bdNode::msgout_pong(bdId *id, bdToken *transId) /* generate message, send to udp */ bdToken vid; - int vlen = BITDHT_TOKEN_MAX_LEN; + uint32_t vlen = BITDHT_TOKEN_MAX_LEN; if (mDhtVersion.size() < vlen) { vlen = mDhtVersion.size(); diff --git a/src/bitdht/bdnode.h b/src/bitdht/bdnode.h index 7995f90..f55e8fe 100644 --- a/src/bitdht/bdnode.h +++ b/src/bitdht/bdnode.h @@ -97,6 +97,10 @@ class bdNode bdNode(bdNodeId *id, std::string dhtVersion, std::string bootfile, bdDhtFunctions *fns); + /* startup / shutdown node */ + void restartNode(); + void shutdownNode(); + // virtual so manager can do callback. // peer flags defined in bdiface.h virtual void addPeer(const bdId *id, uint32_t peerflags); @@ -109,6 +113,7 @@ class bdNode void clearQuery(const bdNodeId *id); void QueryStatus(std::map &statusMap); + void iterationOff(); void iteration(); void processRemoteQuery(); void updateStore(); @@ -176,6 +181,8 @@ void recvPkt(char *msg, int len, struct sockaddr_in addr); void printStats(std::ostream &out); void printQueries(); + void resetCounters(); + void resetStats(); protected: diff --git a/src/bitdht/bdpeer.cc b/src/bitdht/bdpeer.cc index d6af6a6..03a54a9 100644 --- a/src/bitdht/bdpeer.cc +++ b/src/bitdht/bdpeer.cc @@ -313,6 +313,19 @@ bdSpace::bdSpace(bdNodeId *ownId, bdDhtFunctions *fns) return; } + /* empty the buckets */ +int bdSpace::clear() +{ + std::vector::iterator it; + /* iterate through the buckets, and sort by distance */ + for(it = buckets.begin(); it != buckets.end(); it++) + { + it->entries.clear(); + } + return 1; +} + + int bdSpace::find_nearest_nodes(const bdNodeId *id, int number, std::list /*excluding*/, std::multimap &nearest) { std::multimap closest; @@ -735,7 +748,84 @@ int bdSpace::printDHT() } -int bdSpace::calcSizes() +uint32_t bdSpace::calcNetworkSize() +{ + std::vector::iterator it; + + /* little summary */ + unsigned long long sum = 0; + unsigned long long no_peers = 0; + uint32_t count = 0; + bool doPrint = false; + bool doAvg = false; + + int i = 0; + for(it = buckets.begin(); it != buckets.end(); it++, i++) + { + int size = it->entries.size(); + int shift = BITDHT_KEY_BITLEN - i; + bool toBig = false; + + if (shift > BITDHT_ULLONG_BITS - mFns->bdBucketBitSize() - 1) + { + toBig = true; + shift = BITDHT_ULLONG_BITS - mFns->bdBucketBitSize() - 1; + } + unsigned long long no_nets = ((unsigned long long) 1 << shift); + + /* use doPrint so it acts as a single switch */ + if (size && !doAvg && !doPrint) + { + doAvg = true; + } + + if (size && !doPrint) + { + doPrint = true; + } + + if (size == 0) + { + /* reset counters - if empty slot - to discount outliers in average */ + sum = 0; + no_peers = 0; + count = 0; + } + + if (!toBig) + { + no_peers = no_nets * size; + } + + if (doPrint && doAvg && !toBig) + { + if (size == mFns->bdNodesPerBucket()) + { + /* last average */ + doAvg = false; + } + if (no_peers != 0) + { + sum += no_peers; + count++; + } + } + } + + + uint32_t NetSize = 0; + if (count != 0) + { + NetSize = sum / count; + } + + //std::cerr << "bdSpace::calcNetworkSize() : " << NetSize; + //std::cerr << std::endl; + + return NetSize; +} + +uint32_t bdSpace::calcNetworkSizeWithFlag(uint32_t withFlag) { std::vector::iterator it; @@ -750,7 +840,16 @@ int bdSpace::calcSizes() int i = 0; for(it = buckets.begin(); it != buckets.end(); it++, i++) { - int size = it->entries.size(); + int size = 0; + std::list::iterator lit; + for(lit = it->entries.begin(); lit != it->entries.end(); lit++) + { + if (withFlag & lit->mPeerFlags) + { + size++; + } + } + totalcount += size; int shift = BITDHT_KEY_BITLEN - i; @@ -804,31 +903,29 @@ int bdSpace::calcSizes() } - mLastSize = totalcount; - if (count == 0) + uint32_t NetSize = 0; + if (count != 0) { - mLastNetSize = 0; - } - else - { - mLastNetSize = sum / count; + NetSize = sum / count; } - return 1; + //std::cerr << "bdSpace::calcNetworkSize() : " << NetSize; + //std::cerr << std::endl; + + return NetSize; } -uint32_t bdSpace::size() + +uint32_t bdSpace::calcSpaceSize() { - calcSizes(); - return mLastSize; + std::vector::iterator it; + + /* little summary */ + uint32_t totalcount = 0; + for(it = buckets.begin(); it != buckets.end(); it++) + { + totalcount += it->entries.size(); + } + return totalcount; } -uint32_t bdSpace::netSize() -{ - calcSizes(); - return mLastNetSize; -} - - - - diff --git a/src/bitdht/bdpeer.h b/src/bitdht/bdpeer.h index 771c116..35dbf34 100644 --- a/src/bitdht/bdpeer.h +++ b/src/bitdht/bdpeer.h @@ -146,6 +146,8 @@ class bdSpace bdSpace(bdNodeId *ownId, bdDhtFunctions *fns); +int clear(); + /* accessors */ int find_nearest_nodes(const bdNodeId *id, int number, std::list excluding, std::multimap &nearest); @@ -154,9 +156,9 @@ int out_of_date_peer(bdId &id); // side-effect updates, send flag on peer. int add_peer(const bdId *id, uint32_t mode); int printDHT(); -int calcSizes(); -uint32_t size(); -uint32_t netSize(); +uint32_t calcNetworkSize(); +uint32_t calcNetworkSizeWithFlag(uint32_t withFlag); +uint32_t calcSpaceSize(); /* to add later */ int updateOwnId(bdNodeId *newOwnId); @@ -166,9 +168,6 @@ int updateOwnId(bdNodeId *newOwnId); std::vector buckets; bdNodeId mOwnId; bdDhtFunctions *mFns; - - uint32_t mLastSize; - uint32_t mLastNetSize; }; diff --git a/src/bitdht/bdstore.cc b/src/bitdht/bdstore.cc index 6efacac..9921c6f 100644 --- a/src/bitdht/bdstore.cc +++ b/src/bitdht/bdstore.cc @@ -41,14 +41,27 @@ bdStore::bdStore(std::string file, bdDhtFunctions *fns) #endif /* read data from file */ - mIndex = 0; mStoreFile = file; - FILE *fd = fopen(file.c_str(), "r"); + reloadFromStore(); +} + +int bdStore::clear() +{ + mIndex = 0; + store.clear(); + return 1; +} + +int bdStore::reloadFromStore() +{ + clear(); + + FILE *fd = fopen(mStoreFile.c_str(), "r"); if (!fd) { - fprintf(stderr, "Failed to Open File: %s ... No Peers\n", file.c_str()); - return; + fprintf(stderr, "Failed to Open File: %s ... No Peers\n", mStoreFile.c_str()); + return 0; } @@ -84,6 +97,8 @@ bdStore::bdStore(std::string file, bdDhtFunctions *fns) fprintf(stderr, "Read %ld Peers\n", (long) store.size()); #endif + return 1; + } int bdStore::getPeer(bdPeer *peer) diff --git a/src/bitdht/bdstore.h b/src/bitdht/bdstore.h index 6642d4b..51f566a 100644 --- a/src/bitdht/bdstore.h +++ b/src/bitdht/bdstore.h @@ -36,6 +36,10 @@ class bdStore public: bdStore(std::string file, bdDhtFunctions *fns); + +int reloadFromStore(); /* for restarts */ +int clear(); + int getPeer(bdPeer *peer); void addStore(bdPeer *peer); void writeStore(std::string file); diff --git a/src/tests/bdboot.txt b/src/tests/bdboot.txt index 86d9341..d8d0aed 100644 --- a/src/tests/bdboot.txt +++ b/src/tests/bdboot.txt @@ -1,500 +1,500 @@ -142.177.246.95 59112 -116.2.32.161 20124 -188.126.46.50 44950 -95.179.25.105 20206 -95.68.47.164 30021 -58.123.157.201 26652 -201.153.228.202 21677 -121.44.92.49 46001 -80.98.231.47 26348 -77.81.214.54 55140 -188.2.177.127 18893 -77.106.248.215 61010 -92.40.218.25 17436 -79.11.74.201 25511 -124.217.18.33 52665 -110.139.49.2 10021 -116.75.93.225 17753 -91.154.247.194 47519 -85.157.34.95 39877 -87.207.198.164 57380 -76.88.103.96 6688 -69.156.182.48 9745 -174.118.75.21 57528 -78.131.114.243 35625 -85.120.227.7 39679 -67.21.102.65 61696 -90.20.253.243 17134 -77.106.112.192 63044 -89.132.70.154 54892 -89.228.34.41 11402 -99.16.45.162 58728 -114.169.35.228 10609 -119.247.254.79 5294 -62.194.214.11 53956 -86.140.220.164 63805 -89.209.84.223 45645 -71.176.151.158 34312 -87.252.246.164 10004 -174.6.184.150 55074 -122.116.144.204 6881 -188.126.95.124 51422 -178.40.80.76 14409 -71.167.112.211 6881 -204.210.194.241 6881 -99.0.82.216 51494 -109.124.16.234 11636 -220.131.73.187 20718 -178.88.8.252 56292 -83.87.238.214 6881 -87.78.183.103 24204 -92.249.133.6 6754 -81.225.216.54 53358 -89.166.108.48 47175 -109.194.46.208 80 -24.252.70.24 52516 -78.154.10.6 35981 -99.1.110.3 22440 -201.53.55.59 61292 -95.58.92.65 48802 -89.178.134.24 64389 -76.215.117.211 51413 -114.27.89.171 43349 -80.99.42.137 10566 -187.20.103.130 16333 -213.85.141.144 46456 -85.186.48.10 25274 -70.48.43.93 59364 -114.154.228.24 14512 -202.67.20.232 13380 -94.15.164.174 45657 -151.56.153.203 10006 -92.243.177.118 26338 -95.71.69.196 25226 -98.117.36.191 56023 -209.222.54.23 6881 -79.141.52.134 48614 -82.4.38.3 60580 -77.160.150.63 12348 -95.132.188.142 16747 -89.123.135.44 12967 -24.242.52.51 41199 -84.3.164.209 38059 -67.61.48.132 51772 -75.51.92.53 46369 -61.56.132.76 23439 -112.104.6.195 21025 -78.116.106.245 29797 -62.205.245.195 43207 -188.24.228.246 48433 -188.241.183.77 41892 -95.78.151.107 28055 -91.144.104.160 40122 -203.135.35.68 16058 -94.180.34.231 18040 -216.186.213.183 34057 -182.88.83.202 6881 -188.163.76.190 51413 -77.71.45.107 63222 -71.63.16.85 44949 -68.215.227.132 50513 -62.228.103.223 11249 -118.168.199.192 21018 -89.103.74.81 11790 -77.110.201.72 55144 -87.21.255.123 32743 -72.39.132.149 11229 -178.49.20.218 42235 -87.121.209.168 27230 -118.108.135.76 22708 -112.144.249.69 17601 -85.210.192.179 53929 -95.143.216.174 25887 -95.43.73.227 25933 -208.70.61.203 18073 -70.178.206.42 24881 -189.24.23.171 60416 -62.201.119.41 61849 -87.206.75.146 6881 -78.176.207.54 6881 -78.163.164.237 24362 -99.190.51.250 59551 -76.252.236.215 19134 -98.242.28.163 26145 -99.50.200.151 53564 -220.98.144.232 22922 -79.113.121.141 35771 -98.148.246.127 50300 -142.68.210.47 63653 -218.168.225.229 22678 -92.104.49.179 8500 -173.32.63.117 61054 -87.121.173.150 6148 -83.251.66.66 65052 -91.154.137.162 11984 -80.171.58.170 22797 -94.27.109.220 36053 -118.160.53.83 12731 -216.138.216.227 49001 -187.16.62.58 63388 -121.80.39.231 18252 -213.112.106.243 18786 -79.113.182.121 42808 -82.119.65.229 41614 -121.124.190.173 50282 -117.194.194.73 13257 -93.102.129.104 36854 -92.104.22.153 6881 -68.203.251.86 18992 -173.51.127.134 33785 -98.232.90.6 53436 -59.98.161.236 62056 -201.87.32.172 36138 -88.115.78.139 15273 -123.117.107.29 19970 -93.96.190.204 6883 -78.96.174.224 60387 -68.40.87.11 37253 -77.101.133.246 14789 -115.143.47.172 30429 -93.100.92.224 27243 -80.80.153.98 11832 -91.206.4.9 3333 -188.35.8.236 62459 -24.22.195.49 6881 -76.101.135.11 20009 -193.106.25.130 57020 -79.107.183.240 45683 -71.229.83.233 45682 -76.88.94.229 37557 -76.21.110.223 51413 -99.40.159.122 25946 -88.173.24.47 41595 -67.149.36.107 40347 -201.155.152.51 10196 -118.128.22.37 37251 -95.143.25.198 47616 -92.144.60.92 13751 -86.197.129.179 47067 -99.66.5.48 21364 -99.48.229.94 25361 -121.254.45.84 6800 -188.248.58.21 50340 -95.26.55.82 59164 -62.221.151.184 20536 -109.201.74.159 10207 -203.185.36.12 19872 -210.73.1.92 12469 -218.171.240.219 10236 -173.73.187.215 37840 -86.10.229.246 27857 -119.247.45.173 10745 -79.113.175.185 50877 -95.31.11.189 6886 -90.49.27.240 50510 -188.4.197.57 59491 -84.101.189.175 19015 -67.189.42.213 53943 -113.199.242.93 35720 -183.179.97.20 24840 -121.45.215.192 58823 -121.219.253.112 31161 -118.137.194.171 26705 -210.6.173.121 14972 -87.194.243.159 64670 -83.77.171.200 15846 -84.52.63.250 14255 -173.75.218.211 63205 -122.118.67.231 23915 -83.9.39.33 22798 -94.69.249.98 48057 -88.106.69.215 11924 -88.89.180.142 10766 -77.45.166.176 32802 -24.14.73.12 40442 -123.203.168.108 16828 -110.4.246.105 15045 -88.215.184.26 52757 -74.68.145.105 11524 -112.70.90.34 7793 -89.216.145.232 57343 -86.207.79.244 19560 -67.86.153.146 61010 -92.83.127.98 18709 -116.15.128.30 9998 -203.59.10.85 22847 -182.93.10.208 13054 -79.17.30.127 32896 -123.118.137.119 25421 -219.175.138.61 23739 -95.96.188.23 12400 -24.98.183.64 57540 -93.123.41.127 23436 -173.87.8.115 22866 -189.19.100.69 1224 -220.102.166.142 27156 -82.25.111.214 21311 -193.201.198.253 63408 -173.71.152.93 50989 -70.119.159.158 62727 -86.176.212.56 53046 -74.78.254.79 55775 -124.37.161.214 10990 -123.204.252.197 10037 -78.233.97.234 28751 -78.106.52.107 15048 -89.211.154.147 57399 -78.92.20.255 14850 -76.22.26.195 10269 -60.46.193.129 20326 -89.132.136.252 51385 -122.217.69.120 21438 -24.184.162.88 20212 -71.139.186.245 31114 -93.94.21.27 15252 -87.70.142.8 15960 -98.135.71.79 29008 -117.47.90.194 10016 -76.65.18.45 7700 -87.224.254.21 25388 -93.84.84.155 51757 -213.16.120.166 54701 -92.81.249.11 11185 -77.54.70.32 35815 -60.244.140.57 12687 -109.165.40.174 23806 -147.46.216.167 50410 -180.25.22.176 40005 -71.12.16.186 11422 -88.141.135.252 58810 -92.112.66.105 55311 -111.249.218.164 56509 -41.223.241.48 38494 -80.99.189.105 50001 -95.32.38.47 31175 -92.28.148.131 22902 -114.42.222.199 22443 -175.115.187.64 13038 -114.44.107.200 17500 -81.50.148.235 64081 -88.230.2.13 41680 -60.49.48.177 21184 -86.43.195.228 39164 -88.237.29.153 14665 -86.126.237.42 49627 -68.37.160.28 29734 -123.123.0.174 16330 -84.215.70.237 25116 -200.118.51.152 23106 -92.62.116.14 38298 -189.115.242.12 16373 -86.126.244.83 10358 -93.86.94.198 12077 -220.134.70.7 57682 -81.101.108.205 62082 -80.48.112.175 24917 -94.27.95.56 25376 -41.239.99.14 16942 -89.190.216.86 53241 -58.152.99.134 16001 -124.181.115.135 34574 -110.226.38.196 11614 -117.254.176.138 24325 -67.164.200.224 40281 -94.125.247.162 22331 -213.130.92.78 32973 -70.26.64.139 26358 -219.70.171.198 18038 -189.78.31.162 39736 -86.184.173.124 63265 -118.170.7.23 26814 -186.45.139.74 12756 -116.88.194.226 8883 -114.47.171.209 21087 -76.177.235.15 13961 -178.164.177.154 8929 -77.41.69.144 58436 -93.152.162.14 42404 -72.39.29.128 22844 -70.160.28.191 29602 -24.87.88.9 49947 -41.204.126.178 11275 -71.227.139.224 32093 -76.28.227.60 10277 -212.80.48.31 11175 -95.130.12.19 61050 -66.197.165.38 6821 -72.12.147.238 48200 -80.190.139.91 6892 -77.108.227.234 46150 -69.61.67.154 51413 -209.82.182.182 46512 -76.83.2.223 51867 -76.189.218.104 31714 -174.100.244.175 32360 -178.162.183.226 6821 -78.72.106.34 53188 -188.134.14.120 9089 -94.31.232.73 47220 -24.12.33.224 25976 -24.250.154.26 52769 -84.86.167.83 49250 -109.87.83.228 48931 -88.162.153.3 45698 -178.82.201.203 12055 -67.215.242.138 6881 -173.50.147.111 55669 -67.240.191.70 53081 -68.62.10.72 22867 -88.184.85.157 40478 -24.35.86.183 48539 -67.183.139.6 29721 -219.112.140.25 16297 -110.175.157.60 12000 -70.178.210.213 38087 -77.93.16.43 35431 -222.164.18.139 6881 -83.248.90.115 53778 -98.254.244.165 56359 -90.180.166.149 6880 -88.177.195.185 20299 -67.215.242.139 6881 -86.13.80.190 51326 -86.107.79.233 49905 -212.242.219.216 47000 -95.76.50.171 19698 -81.106.247.102 19244 -188.134.67.102 6882 -81.236.226.106 6882 -94.47.188.106 56342 -200.29.72.19 46935 -99.139.154.78 8877 -84.124.205.238 23020 -213.125.29.122 6881 -68.149.168.121 64750 -99.57.47.134 19965 -24.49.177.89 40029 -221.46.51.137 22507 -85.12.239.118 64317 -78.90.116.74 19466 -95.79.41.39 40496 -213.133.98.4 6881 -71.170.86.79 20322 -90.154.242.204 59379 -195.184.205.254 14834 -201.37.1.184 20996 -183.179.244.186 17518 -98.219.151.25 33246 -99.25.55.50 63685 -95.90.32.98 21015 -66.197.165.51 6821 -68.44.82.53 12371 -24.186.168.108 36916 -74.79.37.90 31551 -207.38.168.53 44635 -209.202.78.188 14812 -76.101.24.82 13823 -68.46.57.52 11695 -189.122.64.147 24387 -123.163.132.87 64425 -125.24.191.183 32201 -123.231.81.151 45682 -76.189.50.158 29456 -212.117.167.140 10005 -82.75.135.251 49155 -77.250.123.105 6884 -83.25.71.129 43558 -212.117.1.153 17845 -95.84.155.141 21057 -195.22.140.72 4214 -84.40.91.202 42870 -85.10.46.180 24142 -174.112.6.77 6881 -151.12.60.142 42488 -70.162.99.44 54092 -193.91.144.166 43190 -213.60.233.181 34385 -71.235.207.19 53148 -114.42.20.220 14842 -81.98.127.164 48895 -213.10.67.211 17030 -62.45.245.22 6881 -80.82.92.76 29221 -89.28.27.55 17886 -69.151.72.98 12345 -78.187.75.191 41182 -122.173.206.18 21221 -75.53.192.65 56862 -123.204.71.15 12632 -213.46.44.100 59580 -76.115.102.119 40940 -85.227.178.143 25158 -79.129.187.145 16458 -195.98.76.238 24480 -85.227.228.157 51413 -83.252.123.146 58345 +117.207.214.217 54937 86.110.176.106 30000 -74.13.82.92 6881 -92.33.129.197 16432 -109.252.111.191 33426 -188.17.177.14 23023 -94.232.104.14 59873 -60.54.43.194 14046 -122.211.106.11 14409 -113.10.81.130 18145 -193.23.54.47 23933 -151.46.167.111 14107 -74.73.144.128 8944 -188.168.34.126 50862 -85.30.148.74 34178 -83.99.166.208 32575 -109.226.90.250 59039 -216.252.93.187 10248 -201.127.74.88 23041 -220.232.101.77 10765 +220.134.120.229 6881 +41.228.251.92 47814 +78.62.131.230 50104 +24.150.5.250 51413 +76.110.187.39 14164 +65.184.131.218 6881 +111.119.246.115 22046 +68.96.113.203 14608 +85.99.200.222 27808 +184.56.211.105 52867 +66.31.185.120 10317 +218.145.169.134 3149 +219.161.251.38 31529 +99.101.221.11 11764 +109.192.73.224 52318 +98.242.28.163 26145 +188.81.211.246 8080 +80.254.125.140 34296 64.53.28.136 10809 -111.254.1.128 17447 -74.44.148.55 34665 -84.10.244.103 48553 -109.173.50.36 49288 -84.3.119.233 45000 -216.121.134.38 10348 -77.49.255.137 38764 -96.252.163.120 35217 -72.89.151.90 17320 -89.168.85.181 15348 -124.84.78.74 10674 -190.188.199.13 62986 -94.254.73.152 44229 -192.188.244.1 10634 -84.215.248.234 40991 -79.119.111.31 63150 -95.155.230.83 54993 -83.85.60.232 6881 -178.130.32.118 14247 +67.149.152.217 41077 +91.86.3.133 32176 +95.221.19.39 12976 +83.83.80.92 6881 +87.252.162.190 56515 +151.66.131.139 46954 +78.58.202.177 59464 +71.199.157.116 30520 +96.254.62.199 8200 +24.14.102.44 44245 +70.127.115.202 38183 +99.189.18.223 41292 +213.213.218.65 60981 +190.50.213.190 36891 +118.171.47.177 16001 +119.83.243.224 16654 +113.190.134.153 20216 +114.42.139.73 16001 +182.88.142.211 37365 +119.6.28.67 18045 +85.241.136.42 60048 +68.40.16.60 11232 +212.122.106.140 31783 +109.173.59.147 12962 +95.27.70.32 35054 +77.37.202.193 36299 +178.82.201.203 12055 +109.161.85.240 44209 +94.24.232.164 1500 +75.73.169.64 22011 +90.142.147.91 51488 +76.92.206.199 14832 +99.57.74.12 50424 +173.60.116.127 55492 +99.90.234.80 54989 +99.192.38.145 50847 +85.240.71.5 32193 +98.219.151.25 33246 +81.236.226.106 6882 +89.88.117.136 50637 +91.117.62.76 34004 +99.230.133.39 9536 +74.69.217.130 36242 +86.23.42.71 50946 +66.249.57.76 57217 +210.89.51.164 52413 +76.226.51.91 12663 +24.64.83.1 45429 +117.198.144.222 21855 +64.166.166.167 22837 +91.202.9.75 35691 +24.158.190.101 30993 +124.144.30.72 34172 +98.220.212.46 13972 +221.86.239.1 11798 +68.190.208.15 50557 +68.203.251.86 18992 +178.92.94.213 56595 +89.212.178.131 64999 +178.140.66.146 47690 +212.2.140.47 35691 +93.100.231.80 33103 +95.25.141.71 60569 +109.87.58.45 36303 +46.0.141.155 11396 +87.97.230.29 21009 +119.56.32.42 32382 +92.124.53.28 46108 +89.134.67.24 14172 +114.38.122.171 40232 +114.41.85.198 59723 +122.148.239.163 6881 +112.205.134.194 55288 +78.147.163.160 14027 +122.104.168.226 13618 +138.217.156.134 63770 +117.254.208.18 40438 +75.3.113.99 6881 +84.29.97.213 15577 +91.211.83.75 61617 +93.2.244.233 43565 +86.139.36.0 12037 +87.59.181.239 62153 +174.112.6.77 6881 +24.60.73.227 45502 +69.137.165.233 6881 +76.30.10.86 6881 +24.79.144.209 34882 +84.127.134.131 25717 +98.193.20.11 58714 +95.165.18.201 17170 +189.12.171.99 13596 +94.128.46.21 8827 +60.34.66.88 25136 +95.130.12.19 61050 +77.250.121.26 51413 +77.70.21.207 64309 +213.133.98.4 6881 +69.137.229.111 8500 +109.184.173.10 10058 +65.6.149.143 63622 +82.194.190.194 36219 +59.99.200.15 50007 +98.180.221.118 37950 +111.243.51.215 17517 +125.27.60.193 55555 +85.142.208.26 18256 +87.120.157.123 6073 +90.155.192.228 59169 +91.103.205.231 30573 +85.12.239.118 64317 +174.64.9.192 25397 +78.100.208.205 39074 +66.229.163.248 41546 +123.204.158.238 6881 +94.6.215.232 35125 +120.144.133.123 41889 +203.218.92.102 13383 +111.250.205.16 16001 +91.179.186.59 12654 +84.234.241.206 62793 +84.211.40.116 26202 +213.66.1.88 31701 +109.93.197.4 15932 +84.238.182.126 18755 +86.107.219.33 29748 +94.251.22.96 6890 +94.28.27.245 10249 +88.167.63.173 17155 +95.160.98.229 19948 +76.230.136.237 51413 +88.160.107.217 33383 +75.1.151.129 42526 +80.99.198.116 51819 +175.144.252.191 1722 +67.140.208.226 44078 +118.157.66.146 15267 +88.89.93.181 6881 +188.195.214.69 9089 +90.214.16.2 10050 +24.47.133.24 27457 +88.186.78.58 53354 +178.128.240.54 33591 +67.215.242.139 6881 +79.110.118.172 17827 +85.17.74.169 6881 +190.150.26.121 23765 +189.5.90.211 16422 +71.110.78.125 50924 +112.104.174.102 25693 +222.145.168.62 64457 +125.25.169.12 46286 +79.84.4.144 16887 +95.52.76.243 27570 +151.32.158.158 10464 +189.4.13.169 60285 +70.189.217.212 39037 +119.117.135.178 13778 +85.24.236.236 60224 +77.110.26.188 19101 +90.199.170.34 10491 +212.187.127.4 42544 +213.167.146.216 62238 +24.36.225.41 13970 +88.162.153.3 45698 +67.167.185.252 36758 +119.234.57.170 42523 +118.93.145.87 27871 +118.19.235.114 22136 +124.244.75.29 50766 +114.26.158.95 20185 +143.238.237.25 14151 +2.85.8.6 53180 +112.105.159.195 21721 +77.249.209.133 41620 +109.230.14.32 30747 +86.101.42.86 27426 +213.149.144.24 23206 +85.226.150.37 17020 +95.42.53.21 50840 +91.146.51.190 52891 +79.139.234.104 16939 +93.0.225.253 15592 +98.254.244.165 56359 +114.44.224.46 24232 +60.50.37.37 63880 +119.56.90.14 6884 +222.134.253.50 25460 +200.82.124.226 11216 +86.124.181.25 41812 +151.71.224.236 26022 +78.128.123.63 22260 +79.44.193.147 46988 +81.88.124.26 25171 +92.140.191.170 10583 +74.192.41.234 12306 +24.11.0.152 6881 +98.162.214.118 6881 +76.112.183.73 16254 +217.217.35.121 32001 +67.175.133.224 32772 78.36.196.61 59269 -76.29.12.37 12308 -78.180.216.41 17351 -61.231.198.76 14685 -118.14.157.125 21624 -71.62.37.197 7914 -71.29.78.193 55989 -118.18.244.181 25949 -92.97.196.183 42303 -118.104.11.221 21289 -190.174.204.226 42233 -89.134.203.232 17633 -95.26.152.248 60268 -46.0.3.147 27613 -24.49.32.34 28441 -99.23.91.163 15016 -90.209.174.130 21332 -71.17.47.149 53164 -119.246.176.132 6881 -111.249.153.64 21540 -123.119.85.79 24805 -116.15.111.133 44914 -109.154.116.92 24460 -142.167.215.241 12277 -78.8.106.8 50000 -78.8.193.215 64759 +76.234.70.144 63498 +118.165.101.148 25966 +78.29.72.239 10169 +88.203.69.43 20846 +85.230.126.66 59655 +114.33.208.192 6881 +213.137.40.155 28447 +79.40.28.4 22978 +85.220.113.75 44116 +2.85.54.157 26621 +92.82.169.146 10122 +24.191.39.52 13692 +24.92.85.17 41738 +222.164.18.139 6881 +59.156.223.119 58460 +201.24.51.203 18936 +210.207.227.15 54112 +220.135.104.71 6885 +111.166.209.176 16001 +120.83.182.73 44755 +203.219.45.127 56366 +92.27.98.236 42249 +213.107.103.7 26498 +87.194.35.172 19102 +85.155.45.17 26814 +80.190.139.91 6895 +80.202.98.113 24874 +95.143.217.5 26620 +87.121.131.142 18291 +68.37.105.85 18621 +76.125.40.83 36132 +76.83.2.223 51867 +82.130.145.80 10145 +116.49.130.251 42663 +219.95.36.65 22024 +93.138.138.25 36193 +125.198.109.94 25391 +118.166.52.195 7613 +125.214.154.196 14295 +189.93.138.193 30752 +212.116.83.37 48862 +89.178.0.217 51413 +95.95.243.42 63297 +92.63.29.186 35073 +213.100.103.111 59606 +212.40.113.62 19734 +71.206.232.202 46400 +70.119.92.84 32082 +78.101.105.86 17183 +173.58.66.221 26774 +94.28.105.90 37707 +86.26.47.187 20295 +70.52.182.161 20499 +95.111.185.235 48104 +122.94.252.223 21574 +113.20.82.4 11560 +1.23.143.146 24679 +114.40.118.14 21330 +85.181.59.132 34288 +118.154.53.162 16234 +109.174.68.4 51490 +109.201.74.210 20655 +75.62.19.231 37592 +97.85.74.36 14594 +83.233.120.5 51800 +64.231.15.87 45129 +24.85.138.161 26724 +147.32.8.69 6881 +88.216.128.98 32122 +142.167.5.37 29661 +68.4.207.220 63881 +98.237.164.36 52796 +99.109.20.192 16385 +91.105.126.138 33105 +111.255.46.225 26839 +85.10.3.55 58402 +123.243.29.227 37451 +94.153.114.233 34599 +94.75.136.162 31042 +112.204.106.67 48691 +217.120.148.194 51615 +109.121.134.46 64548 +178.150.86.230 63371 +188.153.7.124 29949 +2.55.82.43 18407 +95.58.44.125 11121 +116.74.115.65 32886 +83.131.71.123 39603 +99.148.166.253 49200 +99.179.93.192 26004 +117.200.32.60 33696 +190.193.153.225 26735 +68.103.246.183 62692 +92.23.100.103 20962 +82.48.131.139 6881 +96.50.99.76 40637 +183.83.0.210 55716 +94.156.160.208 1296 +99.240.114.49 60001 +123.238.20.56 11495 +98.164.225.18 51413 +83.248.115.125 48880 +77.50.124.217 45561 +195.13.160.107 40473 +91.185.36.137 16415 +68.189.164.175 35316 +90.163.159.154 48436 +124.8.223.66 16880 +24.161.134.16 23585 +72.12.147.238 48200 +77.99.163.56 14408 +79.165.239.5 41714 +95.34.50.159 33001 +92.150.184.16 57367 +76.120.195.253 52729 +87.238.1.77 20617 +115.134.213.88 22989 +94.59.123.17 45340 +189.6.134.85 16228 +201.198.78.18 24646 +82.244.111.116 50102 +78.159.163.4 16880 +203.214.42.15 35239 +142.177.246.150 41881 +220.253.180.201 51413 +86.16.190.229 51413 +81.89.106.209 51413 +88.207.84.240 34723 +79.108.206.28 16866 +193.11.162.109 40000 +88.222.107.185 23367 +85.73.84.231 52545 +81.249.93.113 53727 +69.119.12.235 16181 +94.97.7.171 21608 +88.194.178.213 36956 +83.10.93.128 17371 +121.166.23.3 19226 +85.136.235.241 10889 +219.69.115.178 21604 +220.136.219.134 19860 +112.118.91.195 25949 +189.74.105.192 1730 +72.53.76.39 55501 +213.64.51.135 35114 +74.105.9.97 62498 +79.56.233.96 37086 +95.84.0.84 20090 +70.75.213.15 20077 +24.21.100.94 28550 +208.118.23.71 56690 +88.109.14.155 34392 +189.236.5.200 26306 +80.184.65.55 12052 +90.151.185.253 49653 +140.136.239.153 51413 +119.77.220.96 22438 +75.11.180.71 21205 +114.76.81.8 20869 +93.81.137.222 59627 +99.249.255.103 21609 +82.207.43.123 12452 +94.72.123.6 16660 +67.168.18.61 46759 +216.8.170.95 44302 +95.59.128.199 30499 +190.159.56.248 60787 +24.15.32.32 32241 +114.249.142.149 23363 +78.86.71.118 23744 +89.160.3.33 10132 +89.152.240.196 32504 +94.244.172.119 28248 +95.245.89.123 7881 +88.87.1.254 20493 +195.182.132.66 64356 +94.64.144.11 7110 +99.240.139.107 6881 +71.91.56.80 19492 +82.245.161.72 29889 +41.201.68.118 15497 +119.239.155.80 55121 +200.104.77.39 15443 +201.34.97.64 61884 +121.221.223.224 12114 +123.192.140.58 17701 +158.193.168.5 21798 +78.86.111.253 23576 +88.106.167.216 28781 +188.94.39.175 15010 +213.111.238.195 56312 +78.56.7.200 21846 +94.41.112.123 23918 +85.117.33.27 19637 +209.20.68.239 62368 +190.11.108.123 35985 +89.34.34.249 24474 +89.79.136.193 51413 +95.27.123.195 34348 +87.126.188.76 25422 +195.214.237.249 15300 +80.80.116.100 55993 +180.2.23.99 24383 +76.27.231.95 11423 +188.51.83.143 56717 +92.47.229.200 10385 +210.6.213.167 26301 +112.119.40.105 62294 +24.108.1.66 63373 +184.36.90.143 37107 +182.48.202.118 28011 +114.26.162.140 24871 +67.149.182.183 17372 +220.255.183.95 10793 +89.243.44.234 23297 +118.173.35.219 19018 +124.13.140.102 38007 +112.118.43.128 27673 +188.87.87.100 45595 +173.33.201.88 34218 +184.91.39.18 20931 +208.103.246.149 61903 +114.41.224.18 19562 +91.121.177.18 53140 +178.94.155.182 60556 +211.74.67.111 14181 +199.74.97.182 29255 +94.9.44.224 52476 +189.91.127.145 20801 +109.87.34.215 51413 +82.69.1.251 5001 +125.3.4.166 51187 +69.203.68.51 11758 +96.22.31.154 43510 +174.65.137.136 48100 +190.228.94.165 26710 +187.104.62.61 19789 +188.82.144.27 52696 +219.237.1.104 52827 +82.1.75.63 13312 +83.94.240.45 30864 +87.89.12.207 37559 +59.101.167.84 20459 +203.217.50.120 56814 +219.79.49.98 23007 +221.140.188.163 58808 +24.87.209.90 9344 +82.40.248.27 16676 +99.32.75.52 14690 +220.137.140.31 26831 +83.9.219.77 48034 +79.97.250.119 19888 +212.142.76.123 53413 +94.180.157.168 35124 +216.245.196.72 54821 +116.72.169.167 14492 +189.47.125.243 36874 +94.112.8.99 29633 +117.207.235.231 25849 +173.183.106.57 58370 +95.93.136.147 21175 +99.247.172.168 22177 +77.95.59.144 34007 +111.167.216.189 6881 +95.77.154.219 27317 +71.7.161.68 12588 +115.164.135.201 56196 +122.100.221.107 24300 +213.60.104.227 22642 +113.151.72.159 16352 +218.103.176.234 10519 +88.247.49.186 11074 +83.6.190.105 26554 +76.181.160.45 23986 +216.252.75.148 51413 +88.162.86.247 8444 +89.215.27.13 9200 diff --git a/src/tests/bdmetric_test.cc b/src/tests/bdmetric_test.cc index 4fa5eef..d086579 100644 --- a/src/tests/bdmetric_test.cc +++ b/src/tests/bdmetric_test.cc @@ -29,8 +29,106 @@ #include #include + +#include "utest.h" + +bool test_metric_explicit(); +bool test_metric_random(); + +INITTEST(); + int main(int argc, char **argv) { + std::cerr << "libbitdht: " << argv[0] << std::endl; + + test_metric_explicit(); + + FINALREPORT("libbitdht: Metric Tests"); + return TESTRESULT(); +} + +bool test_metric_explicit() +{ + std::cerr << "test_metric_explicit:" << std::endl; + +#define NUM_IDS 6 + + /* create some ids */ + bdId id[NUM_IDS]; + int i, j; + + /* create a set of known ids ... and + * check the metrics are what we expect. + */ + + for(i = 0; i < NUM_IDS; i++) + { + bdZeroNodeId(&(id[i].id)); + } + + /* test the zero node works */ + for(i = 0; i < NUM_IDS; i++) + { + for(j = 0; j < BITDHT_KEY_LEN; j++) + { + CHECK(id[i].id.data[j] == 0); + } + } + + for(i = 0; i < NUM_IDS; i++) + { + for(j = i; j < NUM_IDS; j++) + { + id[j].id.data[BITDHT_KEY_LEN - i - 1] = 1; + } + } + + for(i = 0; i < NUM_IDS; i++) + { + fprintf(stderr, "id[%d]:", i+1); + bdStdPrintId(std::cerr,&(id[i])); + fprintf(stderr, "\n"); + } + + /* now do the sums */ + bdMetric met; + bdMetric met2; + int bdist = 0; + + for(i = 0; i < 6; i++) + { + for(j = i+1; j < 6; j++) + { + bdStdDistance(&(id[i].id), &(id[j].id), &met); + + fprintf(stderr, "%d^%d:", i, j); + bdStdPrintNodeId(std::cerr,&met); + fprintf(stderr, "\n"); + + bdist = bdStdBucketDistance(&met); + fprintf(stderr, " bucket: %d\n", bdist); + } + } + +#if 0 + int c1 = met < met2; + int c2 = met2 < met; + + fprintf(stderr, "1^2<1^3? : %d 1^3<1^2?: %d\n", c1, c2); +#endif + + + REPORT("Test Byte Manipulation"); + //FAILED("Couldn't Bind to socket"); + + return 1; +} + + + +bool test_metric_random() +{ + std::cerr << "test_metric_random:" << std::endl; /* create some ids */ bdId id1; diff --git a/src/tests/udpbitdht_nettest.cc b/src/tests/udpbitdht_nettest.cc index 4246d26..13809fe 100644 --- a/src/tests/udpbitdht_nettest.cc +++ b/src/tests/udpbitdht_nettest.cc @@ -66,13 +66,21 @@ int main(int argc, char **argv) std::string uid; bool setUid = false; bool doRandomQueries = false; + bool doRestart = false; + bool doThreadJoin = false; srand(time(NULL)); - while((c = getopt(argc, argv,"p:b:u:r")) != -1) + while((c = getopt(argc, argv,"rjp:b:u:q")) != -1) { switch (c) { + case 'r': + doRestart = true; + break; + case 'j': + doThreadJoin = true; + break; case 'p': { int tmp_port = atoi(optarg); @@ -107,7 +115,7 @@ int main(int argc, char **argv) std::cerr << std::endl; } break; - case 'r': + case 'q': { doRandomQueries = true; std::cerr << "Doing Random Queries"; @@ -183,9 +191,29 @@ int main(int argc, char **argv) int count = 0; + int running = 1; + + std::cerr << "Starting Dht: "; + std::cerr << std::endl; + bitdht->startDht(); + + while(1) { sleep(60); + + std::cerr << "BitDht State: "; + std::cerr << bitdht->stateDht(); + std::cerr << std::endl; + + std::cerr << "Dht Network Size: "; + std::cerr << bitdht->statsNetworkSize(); + std::cerr << std::endl; + + std::cerr << "BitDht Network Size: "; + std::cerr << bitdht->statsBDVersionSize(); + std::cerr << std::endl; + if (++count == 2) { /* switch to one-shot searchs */ @@ -196,10 +224,50 @@ int main(int argc, char **argv) { bdNodeId rndId; bdStdRandomNodeId(&rndId); + + std::cerr << "BitDht Launching Random Search: "; + bdStdPrintNodeId(std::cerr, &rndId); + std::cerr << std::endl; + bitdht->addFindNode(&rndId, mode); } - } + if (doThreadJoin) + { + /* change address */ + if (count % 2 == 0) + { + + std::cerr << "Resetting UdpStack: "; + std::cerr << std::endl; + + udpstack->resetAddress(local); + } + } + if (doRestart) + { + if (count % 2 == 1) + { + if (running) + { + + std::cerr << "Stopping Dht: "; + std::cerr << std::endl; + + bitdht->stopDht(); + running = 0; + } + else + { + std::cerr << "Starting Dht: "; + std::cerr << std::endl; + + bitdht->startDht(); + running = 1; + } + } + } + } return 1; } diff --git a/src/tests/utest.h b/src/tests/utest.h new file mode 100644 index 0000000..1ebd987 --- /dev/null +++ b/src/tests/utest.h @@ -0,0 +1,23 @@ +#ifndef _UNIT_TEST_MACROS_H__ +#define _UNIT_TEST_MACROS_H__ + +#include + +#define TFAILURE( s ) printf( "FAILURE: " __FILE__ ":%-4d %s\n", __LINE__, s ) +#define TSUCCESS( s ) printf( "SUCCESS: " __FILE__ ":%-4d %s\n", __LINE__, s ) + +/* careful with this line (no protection) */ +#define INITTEST() int ok = 1; int gok = 1; + +/* declare the variables */ +extern int ok; +extern int gok; + +#define CHECK( b ) do { if ( ! (b) ) { ok = 0; TFAILURE( #b ); } } while(0) +#define FAILED( s ) do { ok = 0; TFAILURE( s ); } while(0) +#define REPORT( s ) do { if ( ! (ok) ) { ok = 0; TFAILURE( s ); } else { TSUCCESS( s );} gok &= ok; ok = 1; } while(0) +#define REPORT2( b, s ) do { if ( ! (b) ) { ok = 0; TFAILURE( s ); } else { TSUCCESS( s );} gok &= ok; ok = 1; } while(0) +#define FINALREPORT( s ) do { gok &= ok; ok = 1; if ( ! (gok) ) { TFAILURE( s ); } else { TSUCCESS( s );} } while(0) +#define TESTRESULT() (!gok) + +#endif diff --git a/src/udp/udpbitdht.cc b/src/udp/udpbitdht.cc index 3ec8261..5f88ed5 100644 --- a/src/udp/udpbitdht.cc +++ b/src/udp/udpbitdht.cc @@ -131,6 +131,43 @@ int UdpBitDht::getDhtValue(const bdNodeId *id, std::string key, std::string &va return mBitDhtManager->getDhtValue(id, key, value); } + + /* stats and Dht state */ +int UdpBitDht:: startDht() +{ + bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/ + + return mBitDhtManager->startDht(); +} + +int UdpBitDht:: stopDht() +{ + bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/ + + return mBitDhtManager->stopDht(); +} + +int UdpBitDht::stateDht() +{ + bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/ + + return mBitDhtManager->stateDht(); +} + +uint32_t UdpBitDht::statsNetworkSize() +{ + bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/ + + return mBitDhtManager->statsNetworkSize(); +} + +uint32_t UdpBitDht::statsBDVersionSize() +{ + bdStackMutex stack(dhtMtx); /********** MUTEX LOCKED *************/ + + return mBitDhtManager->statsBDVersionSize(); +} + /******************* Internals *************************/ /***** Iteration / Loop Management *****/ diff --git a/src/udp/udpbitdht.h b/src/udp/udpbitdht.h index 401e433..41ed517 100644 --- a/src/udp/udpbitdht.h +++ b/src/udp/udpbitdht.h @@ -71,6 +71,13 @@ virtual void removeCallback(BitDhtCallback *cb); virtual int getDhtPeerAddress(const bdNodeId *id, struct sockaddr_in &from); virtual int getDhtValue(const bdNodeId *id, std::string key, std::string &value); + /* stats and Dht state */ +virtual int startDht(); +virtual int stopDht(); +virtual int stateDht(); +virtual uint32_t statsNetworkSize(); +virtual uint32_t statsBDVersionSize(); + /******************* Internals *************************/ /***** Iteration / Loop Management *****/ diff --git a/src/util/bdthreads.cc b/src/util/bdthreads.cc index d56431f..2d70e7f 100644 --- a/src/util/bdthreads.cc +++ b/src/util/bdthreads.cc @@ -32,15 +32,26 @@ * #define DEBUG_THREADS 1 *******/ +#define DEBUG_THREADS 1 + #ifdef DEBUG_THREADS #include #endif extern "C" void* bdthread_init(void* p) { +#ifdef DEBUG_THREADS + std::cerr << "bdthread_init()"; + std::cerr << std::endl; +#endif + bdThread *thread = (bdThread *) p; if (!thread) { +#ifdef DEBUG_THREADS + std::cerr << "bdthread_init() Error Invalid thread pointer."; + std::cerr << std::endl; +#endif return 0; } thread -> run(); @@ -53,19 +64,45 @@ pthread_t createThread(bdThread &thread) pthread_t tid; void *data = (void *) (&thread); +#ifdef DEBUG_THREADS + std::cerr << "createThread() creating a bdThread"; + std::cerr << std::endl; +#endif + thread.mMutex.lock(); { pthread_create(&tid, 0, &bdthread_init, data); thread.mTid = tid; } + +#ifdef DEBUG_THREADS + std::cerr << "createThread() created Thread.mTid: "; + +#if defined(_WIN32) || defined(__MINGW32__) + std::cerr << "WIN32: Cannot print mTid "; +#else + std::cerr << thread.mTid; +#endif + std::cerr << std::endl; + +#endif + thread.mMutex.unlock(); + + return tid; } bdThread::bdThread() { + +#ifdef DEBUG_THREADS + std::cerr << "bdThread::bdThread()"; + std::cerr << std::endl; +#endif + #if defined(_WIN32) || defined(__MINGW32__) memset (&mTid, 0, sizeof(mTid)); #else @@ -75,16 +112,59 @@ bdThread::bdThread() void bdThread::join() /* waits for the the mTid thread to stop */ { +#ifdef DEBUG_THREADS + std::cerr << "bdThread::join() Called! Waiting for Thread.mTid: "; + +#if defined(_WIN32) || defined(__MINGW32__) + std::cerr << "WIN32: Cannot print mTid "; +#else + std::cerr << mTid; +#endif + + std::cerr << std::endl; +#endif + + mMutex.lock(); + { #if defined(_WIN32) || defined(__MINGW32__) /* Its a struct in Windows compile and the member .p ist checked in the pthreads library */ #else if(mTid > 0) #endif pthread_join(mTid, NULL); + +#ifdef DEBUG_THREADS + std::cerr << "bdThread::join() Joined Thread.mTid: "; + +#if defined(_WIN32) || defined(__MINGW32__) + std::cerr << "WIN32: Cannot print mTid "; +#else + std::cerr << mTid; +#endif + + std::cerr << std::endl; + std::cerr << "bdThread::join() Setting mTid = 0"; + std::cerr << std::endl; +#endif + +#if defined(_WIN32) || defined(__MINGW32__) + memset (&mTid, 0, sizeof(mTid)); +#else + mTid = 0; +#endif + + } + mMutex.unlock(); + } void bdThread::stop() { +#ifdef DEBUG_THREADS + std::cerr << "bdThread::stop() Called!"; + std::cerr << std::endl; +#endif + pthread_exit(NULL); }