#include <stdio.h>
#include "pinger.h"
-#include "common.h"
-#include "stg_locker.h"
+#include "stg/common.h"
+#include "stg/locker.h"
#ifdef STG_TIME
extern volatile time_t stgTime;
//-----------------------------------------------------------------------------
STG_PINGER::STG_PINGER(time_t d)
+ : delay(d),
+ nonstop(false),
+ isRunningRecver(false),
+ isRunningSender(false),
+ sendSocket(-1),
+ recvSocket(-1),
+ sendThread(),
+ recvThread(),
+ pmSend(),
+ pid(0),
+ errorStr(),
+ pingIP(),
+ ipToAdd(),
+ ipToDel(),
+ mutex()
{
- delay = d;
pthread_mutex_init(&mutex, NULL);
- pid = 0;
+ memset(&pmSend, 0, sizeof(pmSend));
}
//-----------------------------------------------------------------------------
STG_PINGER::~STG_PINGER()
if (isRunningRecver)
{
//5 seconds to thread stops itself
- int i;
- for (i = 0; i < 25; i++)
+ for (size_t i = 0; i < 25; i++)
{
if (i % 5 == 0)
SendPing(0x0100007f);//127.0.0.1
//after 5 seconds waiting thread still running. now killing it
if (isRunningRecver)
{
- //if (pthread_kill(recvThread, SIGINT))
- // {
+ if (pthread_kill(recvThread, SIGINT))
+ {
errorStr = "Cannot kill thread.";
return -1;
- // }
- //printf("recvThread killed\n");
+ }
}
}
if (isRunningSender)
{
//5 seconds to thread stops itself
- int i;
- for (i = 0; i < 25; i++)
+ for (size_t i = 0; i < 25; i++)
{
if (!isRunningSender)
break;
//after 5 seconds waiting thread still running. now killing it
if (isRunningSender)
{
- //if (pthread_kill(sendThread, SIGINT))
- // {
+ if (pthread_kill(sendThread, SIGINT))
+ {
errorStr = "Cannot kill thread.";
return -1;
- // }
- //printf("sendThread killed\n");
+ }
}
}
void STG_PINGER::AddIP(uint32_t ip)
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
- //printf("AddIP\n");
ipToAdd.push_back(ip);
}
//-----------------------------------------------------------------------------
void STG_PINGER::DelIP(uint32_t ip)
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
- //printf("DelIP\n");
ipToDel.push_back(ip);
}
//-----------------------------------------------------------------------------
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
- list<uint32_t>::iterator iter;
+ std::list<uint32_t>::iterator iter;
iter = ipToAdd.begin();
while (iter != ipToAdd.end())
{
- /*packets.insert(pair<RAW_PACKET, PACKET_EXTRA_DATA>(rawPacket, ed));*/
- //pingIP[*iter] = 0;
- pingIP.insert(pair<uint32_t, time_t>(*iter, 0));
- iter++;
+ pingIP.insert(std::make_pair(*iter, 0));
+ ++iter;
}
ipToAdd.erase(ipToAdd.begin(), ipToAdd.end());
}
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
- list<uint32_t>::iterator iter;
- multimap<uint32_t, time_t>::iterator treeIter;
+ std::list<uint32_t>::iterator iter;
+ std::multimap<uint32_t, time_t>::iterator treeIter;
iter = ipToDel.begin();
while (iter != ipToDel.end())
{
treeIter = pingIP.find(*iter);
- //printf("Found %X\n", *iter);
if (treeIter != pingIP.end())
pingIP.erase(treeIter);
- iter++;
+ ++iter;
}
ipToDel.erase(ipToDel.begin(), ipToDel.end());
}
//-----------------------------------------------------------------------------
-int STG_PINGER::GetPingIPNum()
+int STG_PINGER::GetPingIPNum() const
{
return pingIP.size();
}
//-----------------------------------------------------------------------------
-void STG_PINGER::GetAllIP(vector<PING_IP_TIME> *)
-{
- //STG_LOCKER lock(&mutex, __FILE__, __LINE__);
-}
-//-----------------------------------------------------------------------------
void STG_PINGER::PrintAllIP()
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
- multimap<uint32_t, time_t>::iterator iter;
+ std::multimap<uint32_t, time_t>::iterator iter;
iter = pingIP.begin();
while (iter != pingIP.end())
{
uint32_t ip = iter->first;
time_t t = iter->second;
- string s;
+ std::string s;
x2str(t, s);
printf("ip = %s, time = %9s\n", inet_ntostring(ip).c_str(), s.c_str());
- iter++;
+ ++iter;
}
}
//-----------------------------------------------------------------------------
-int STG_PINGER::GetIPTime(uint32_t ip, time_t * t)
+int STG_PINGER::GetIPTime(uint32_t ip, time_t * t) const
{
STG_LOCKER lock(&mutex, __FILE__, __LINE__);
- multimap<uint32_t, time_t>::iterator treeIter;
+ std::multimap<uint32_t, time_t>::const_iterator treeIter;
treeIter = pingIP.find(ip);
if (treeIter == pingIP.end())
return 0;
}
//-----------------------------------------------------------------------------
-void STG_PINGER::SetDelayTime(time_t d)
-{
- delay = d;
-}
-//-----------------------------------------------------------------------------
-time_t STG_PINGER::GetDelayTime()
-{
- return delay;
-}
-//-----------------------------------------------------------------------------
-string STG_PINGER::GetStrError()
-{
- return errorStr;
-}
-//-----------------------------------------------------------------------------
uint16_t STG_PINGER::PingCheckSum(void * data, int len)
{
unsigned short * buf = (unsigned short *)data;
int STG_PINGER::SendPing(uint32_t ip)
{
struct sockaddr_in addr;
- //printf("SendPing %X \n", ip);
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = 0;
if (sendto(sendSocket, &pmSend, sizeof(pmSend), 0, (sockaddr *)&addr, sizeof(addr)) <= 0 )
{
- errorStr = "Send ping error: " + string(strerror(errno));
+ errorStr = "Send ping error: " + std::string(strerror(errno));
return -1;
}
socklen_t len = sizeof(addr);
bytes = recvfrom(recvSocket, &buf, sizeof(buf), 0, (struct sockaddr*)&addr, &len);
- //printf("recvfrom\n");
if (bytes > 0)
{
struct IP_HDR * ip = (struct IP_HDR *)buf;
struct ICMP_HDR *icmp = (struct ICMP_HDR *)(buf + ip->ihl * 4);
- //printf("icmp->un.echo.id=%d, pid=%d, tid: %d\n", icmp->un.echo.id, pid);
if (icmp->un.echo.id != pid)
return 0;
//-----------------------------------------------------------------------------
void * STG_PINGER::RunSendPing(void * d)
{
- STG_PINGER * pinger = (STG_PINGER*)d;
+ STG_PINGER * pinger = static_cast<STG_PINGER *>(d);
pinger->isRunningSender = true;
time_t lastPing = 0;
pinger->RealAddIP();
pinger->RealDelIP();
- multimap<uint32_t, time_t>::iterator iter;
+ std::multimap<uint32_t, time_t>::iterator iter;
iter = pinger->pingIP.begin();
while (iter != pinger->pingIP.end())
{
- uint32_t ip = iter->first;
- pinger->SendPing(ip);
- iter++;
+ pinger->SendPing(iter->first);
+ ++iter;
}
time_t currTime;
#endif
usleep(20000);
}
- //printf("new ping cycle\n");
}
pinger->isRunningSender = false;
//-----------------------------------------------------------------------------
void * STG_PINGER::RunRecvPing(void * d)
{
- STG_PINGER * pinger = (STG_PINGER*)d;
+ STG_PINGER * pinger = static_cast<STG_PINGER *>(d);
pinger->isRunningRecver = true;
- uint32_t ip;
- multimap<uint32_t, time_t>::iterator treeIterLower;
- multimap<uint32_t, time_t>::iterator treeIterUpper;
-
while (pinger->nonstop)
{
- ip = pinger->RecvPing();
+ uint32_t ip = pinger->RecvPing();
if (ip)
{
- //printf("RecvPing %X\n", ip);
- treeIterUpper = pinger->pingIP.upper_bound(ip);
- treeIterLower = pinger->pingIP.lower_bound(ip);
- int i = 0;
+ std::multimap<uint32_t, time_t>::iterator treeIterUpper = pinger->pingIP.upper_bound(ip);
+ std::multimap<uint32_t, time_t>::iterator treeIterLower = pinger->pingIP.lower_bound(ip);
while (treeIterUpper != treeIterLower)
- //treeIterUpper = pinger->pingIP.find(ip);
- //if (treeIterUpper != pinger->pingIP.end())
{
- //printf("+++! time=%d %X i=%d !+++\n", time(NULL), ip, i);
- //printf("--- time=%d ---\n", time(NULL));
#ifdef STG_TIME
treeIterLower->second = stgTime;
#else
treeIterLower->second = time(NULL);
#endif
++treeIterLower;
- i++;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
-
git.stg.codes / stg.git / blobdiff