void HostCatcher::noteHostBad( HostAddress * inHost ) {
mLock->lock();
// make sure this host already exists in our list
char exists = false;
HostAddress *foundHost = NULL;
int numHosts = mHostVector->size();
for( int i=0; i<numHosts; i++ ) {
HostAddress *otherHost = *( mHostVector->getElement( i ) );
if( otherHost->equals( inHost ) ) {
exists = true;
// delete the host that we've found
mHostVector->deleteElement( i );
foundHost = otherHost;
// jump out of loop
i = numHosts;
}
}
if( exists ) {
delete foundHost;
//mHostVector->push_back( foundHost );
}
mLock->unlock();
}
void HostCatcher::addHost( HostAddress * inHost ) {
// convert to numerical form once and for all here
// (to avoid converting over and over in equals checks below)
HostAddress *numericalAddress = inHost->getNumericalAddress();
if( numericalAddress != NULL ) {
mLock->lock();
// make sure this host doesn't already exist in our list
char exists = false;
int numHosts = mHostVector->size();
for( int i=0; i<numHosts; i++ ) {
HostAddress *otherHost = *( mHostVector->getElement( i ) );
if( otherHost->equals( numericalAddress ) ) {
exists = true;
// jump out of loop
i = numHosts;
}
}
if( !exists ) {
mHostVector->push_back( numericalAddress->copy() );
}
while( mHostVector->size() > mMaxListSize ) {
// remove first host from queue
HostAddress *host = *( mHostVector->getElement( 0 ) );
mHostVector->deleteElement( 0 );
delete host;
}
mLock->unlock();
delete numericalAddress;
}
}
SimpleVector<HostAddress *> *HostCatcher::getHostList(
int inMaxHostCount,
HostAddress *inSkipHost ) {
HostAddress *hostToSkip;
if( inSkipHost != NULL ) {
hostToSkip = inSkipHost->copy();
}
else {
// don't skip any host
// create a dummy host that won't match any other valid hosts
// make sure dummy is in numerical form to avoid DNS lookups
hostToSkip = new HostAddress( stringDuplicate( "1.1.1.1" ), 1 );
}
SimpleVector<HostAddress *> *collectedHosts =
new SimpleVector<HostAddress *>();
char repeat = false;
int numCollected = 0;
// This function assumes that getHostOrdered() draws
// hosts in order with no repetition except when we have
// exhausted the host supply.
// Note that this will not be true when other threads
// have getHostOrdered() (or getHost) calls interleaved with ours, but this
// should be a rare case. It will simply result
// in a smaller host list being returned.
HostAddress *firstHost = getHostOrdered();
if( firstHost == NULL ) {
// the catcher is empty
delete hostToSkip;
// an empty host list
return collectedHosts;
}
if( ! hostToSkip->equals( firstHost ) ) {
collectedHosts->push_back( firstHost );
numCollected++;
}
while( numCollected < inMaxHostCount && !repeat ) {
HostAddress *nextHost = getHostOrdered();
if( nextHost->equals( firstHost ) ) {
delete nextHost;
repeat = true;
}
else {
if( ! hostToSkip->equals( nextHost ) ) {
collectedHosts->push_back( nextHost );
numCollected++;
}
else {
delete nextHost;
}
}
}
if( hostToSkip->equals( firstHost ) ) {
// we didn't include firstHost in our collectedHosts, so
// we must delete it.
delete firstHost;
}
delete hostToSkip;
return collectedHosts;
}
