long long getCurrentTimeMills() { struct timeval tmv; kvi_gettimeofday(&tmv,0); long long result = tmv.tv_sec * 1000 + tmv.tv_usec / 1000; return result; }
unsigned long KviMSecTimeInterval::mark() { struct timeval tmv; kvi_gettimeofday(&tmv,0); unsigned long uDiff = ((((unsigned long)(tmv.tv_sec)) - m_uReferenceSecs) * 1000); if(((unsigned long)(tmv.tv_usec)) > m_uReferenceUSecs)uDiff += (((unsigned long)(tmv.tv_usec) - m_uReferenceUSecs) / 1000); else uDiff -= ((m_uReferenceUSecs - (unsigned long)(tmv.tv_usec)) / 1000); m_uReferenceSecs = (unsigned long)tmv.tv_sec; m_uReferenceUSecs = (unsigned long)tmv.tv_usec; return uDiff; }
void KviApplication::getTmpFileName(QString &szBuffer,const QString &szEndingFileName) { QString tmp; getLocalKvircDirectory(tmp,Tmp); KviQString::ensureLastCharIs(tmp,KVI_PATH_SEPARATOR_CHAR); struct timeval tmv; kvi_gettimeofday(&tmv,0); QString szFileName = szEndingFileName.isNull() ? QString("file.tmp") : szEndingFileName; do { szBuffer = tmp; KviQString::appendFormatted(szBuffer,"kvirc_%d_%Q",tmv.tv_usec,&szFileName); tmv.tv_usec++; } while(KviFileUtils::fileExists(szBuffer)); }
bool KviLagMeter::lagCheckComplete(const char * key) { // find this lag check KviLagCheck * c; for(c = m_pCheckList->first();c;c = m_pCheckList->next()) { if(kvi_strEqualCS(c->szKey.ptr(),key))break; } if(!c)return false; // not found // kill any earlier lag checks (IRC is a sequential proto) while(m_pCheckList->first() != c)m_pCheckList->removeFirst(); if(_OUTPUT_PARANOIC) m_pConnection->console()->output(KVI_OUT_VERBOSE,__tr2qs("Lag check completed (%s)"),key); struct timeval tv; kvi_gettimeofday(&tv,0); unsigned int uLag = ((tv.tv_sec - c->lSecs) * 1000); if(tv.tv_usec < c->lUSecs)uLag -= ((c->lUSecs - tv.tv_usec) / 1000); else uLag += ((tv.tv_usec - c->lUSecs) / 1000); // now check the reliability if(m_uLastReliability > c->uReliability) { // the actual data is more reliable than the new one :/ // change the real lag only by a certain amount // c->uRel : 100 = uLag : m_uLag m_uLag = ((uLag * c->uReliability) + (m_uLag * m_uLastReliability)) / (c->uReliability + m_uLastReliability); } else { // the actual data is less reliable than the new one m_uLag = uLag; } m_tLastCompleted = tv.tv_sec; // now m_tLastOwnCheck = 0; m_tFirstOwnCheck = 0; m_uLastReliability = c->uReliability; m_pCheckList->removeFirst(); return true; }
void KviLagMeter::lagCheckRegister(const char * key,unsigned int uReliability) { if(uReliability < 10)return; // what the heck of a lag check is this ? // store the lagcheck structure and just return if(_OUTPUT_PARANOIC) m_pConnection->console()->output(KVI_OUT_VERBOSE,__tr2qs("Registered lag check with reliability %u (%s)"),uReliability,key); KviLagCheck * c = new KviLagCheck; c->szKey = key; struct timeval tv; kvi_gettimeofday(&tv,0); c->lSecs = tv.tv_sec; c->lUSecs = tv.tv_usec; c->uReliability = uReliability <= 100 ? uReliability : 100; m_pCheckList->append(c); while(m_pCheckList->count() > 30) { // we're fried :/ // either our ping mechanism is not working // or the server is stoned... m_pCheckList->removeFirst(); } }
void KviIrcServer::generateUniqueId() { struct timeval tv; kvi_gettimeofday(&tv,0); m_szId = QString("myserver%1%2%3").arg(tv.tv_usec).arg(rand() % 1000).arg(rand() % 1000); }
void KviLagMeter::timerEvent(QTimerEvent *) { if(m_pConnection->state() != KviIrcConnection::Connected)return; // do nothing atm // If the lag has changed emit our signals if((m_uLag / 10) != (m_uLastEmittedLag / 10)) { m_uLastEmittedLag = m_uLag; g_pMainWindow->childConnectionLagChange(m_pConnection); KviCString szLag(KviCString::Format,"%u",m_uLag); bool bDeletionSignal = false; m_pDeletionSignal = &bDeletionSignal; if((!m_bOnAlarm) && (m_uLag > KVI_OPTION_UINT(KviOption_uintLagAlarmTime))) { KVS_TRIGGER_EVENT_2_HALTED(KviEvent_OnLagAlarmTimeUp, m_pConnection->console(),m_pConnection->serverInfo()->name(),QString(szLag.ptr())); if(bDeletionSignal)return; // killed, probably by a quit -f -u m_bOnAlarm = true; } else if(m_bOnAlarm) { KVS_TRIGGER_EVENT_2_HALTED(KviEvent_OnLagAlarmTimeDown, m_pConnection->console(),m_pConnection->serverInfo()->name(),QString(szLag.ptr())); if(bDeletionSignal)return; // killed, probably by a quit -f -u m_bOnAlarm = false; } KVS_TRIGGER_EVENT_2_HALTED(KviEvent_OnLagCheck, m_pConnection->console(),m_pConnection->serverInfo()->name(),QString(szLag.ptr())); if(bDeletionSignal)return; // killed, probably by a quit -f -u m_pDeletionSignal = 0; } // get current time struct timeval tv; kvi_gettimeofday(&tv,0); unsigned int uDiff = tv.tv_sec - m_tLastCompleted; unsigned int uHeartbeat = KVI_OPTION_UINT(KviOption_uintLagMeterHeartbeat) / 1000; if(uHeartbeat < 2)uHeartbeat = 2; // we keep the last lag value for an amount of time // depending on its reliability. // Since reliability ranges from 10 to 100 we keep the lags // for (hrtbt * 4) + (reliability / 2) seconds (which means from 25 to 70 seconds by default) if(uDiff <= ((uHeartbeat * 4) + (m_uLastReliability / 2)))return; // nothing to do, the actual value is accurate // the last completed check has been completed a lot of time ago // do we have some checks on the queue ? if(m_pCheckList->count() > 0) { // if the first registered check is not too outdated // we wait a little more for it to return KviLagCheck * c = m_pCheckList->first(); if(c) { if((tv.tv_sec - c->lSecs) <= 10)return; } // the first check was registered more than 10 secs before if(m_tLastOwnCheck > 0) { // hm.. we have already sent our own (reliable) check after the last completed // make the lag grow (we're pretty sure it's growing) uDiff = (tv.tv_sec - m_tFirstOwnCheck) * 1000; if(m_uLag < uDiff)m_uLag = uDiff; // the lag grows for sure uDiff = tv.tv_sec - m_tLastOwnCheck; if(uDiff < (uHeartbeat * 4))return; // wait a bit...send own checks only every 20 secs (by default) at this point } } // or we have no checks in the queue at all // or it's really time to do something... if(m_tFirstOwnCheck == 0) { if(_OUTPUT_PARANOIC) m_pConnection->console()->output(KVI_OUT_VERBOSE,__tr2qs("Sending out PING based lag probe")); // this is the first our own lag check since the last succesfull one: use the ping lagCheckRegister("@ping@",70); // the ping may be fooled easily m_pConnection->sendFmtData("PING %s %s", m_pConnection->encodeText( m_pConnection->userInfo()->nickName() ).data(), m_pConnection->encodeText( m_pConnection->serverInfo()->name() ).data() ); m_tFirstOwnCheck = tv.tv_sec; } else { if(_OUTPUT_PARANOIC) m_pConnection->console()->output(KVI_OUT_VERBOSE,__tr2qs("Sending out CTCP based lag probe")); // we have already sent a ping but we got no reply // try with another method... even if this will reset our idle time KviCString tmp(KviCString::Format,"%d%d-yeah-:)",tv.tv_sec,tv.tv_usec); lagCheckRegister(tmp.ptr(),100); // almost impossible to fool m_pConnection->sendFmtData("NOTICE %s :%cLAGCHECK %s%c", m_pConnection->encodeText( m_pConnection->userInfo()->nickName() ).data(), 0x01, tmp.ptr(), 0x01); } m_tLastOwnCheck = tv.tv_sec; }
unsigned int KviLagMeter::secondsSinceLastCompleted() { struct timeval tv; kvi_gettimeofday(&tv,0); return tv.tv_sec - m_tLastCompleted; }