ulong MemInfo::_runCommand()
{
sigar_t *s = NULL;
if (sigar_open(&s) != SIGAR_OK)
{
return 0;
}
char line[MAX_BUF] = {0};
#define MEM_FORMAT_DOUBLE(field) \
sprintf(line, "%12s: %.1lf %%\n", #field, memInfo.field); \
mMyStream<<line; \
#define MEM_FORMAT_INT64(field) \
sprintf(line, "%12s: %s B\n", #field, formatInteger(memInfo.field)); \
mMyStream<<line; \
if (mbPrintSwap)
{
sigar_swap_t memInfo;
if (sigar_swap_get(s, &memInfo) != SIGAR_OK)
{
sigar_close(s);
return 0;
}
MEM_FORMAT_INT64(total);
MEM_FORMAT_INT64(used);
MEM_FORMAT_INT64(free);
MEM_FORMAT_INT64(page_in);
MEM_FORMAT_INT64(page_out);
}
else
{
sigar_mem_t memInfo;
if (sigar_mem_get(s, &memInfo) != SIGAR_OK)
{
sigar_close(s);
return 0;
}
MEM_FORMAT_INT64(ram);
MEM_FORMAT_INT64(total);
MEM_FORMAT_INT64(used);
MEM_FORMAT_INT64(free);
MEM_FORMAT_INT64(actual_used);
MEM_FORMAT_INT64(actual_free);
MEM_FORMAT_DOUBLE(used_percent);
MEM_FORMAT_DOUBLE(free_percent);
}
sigar_close(s);
return mInterval;
}
ulong CpuInfo::_runCommand()
{
sigar_t *s = NULL;
if (sigar_open(&s) != SIGAR_OK)
{
return 0;
}
sigar_cpu_info_list_t cpuinfo;
if (sigar_cpu_info_list_get(s, &cpuinfo) != SIGAR_OK)
{
sigar_close(s);
return 0;
}
char line[MAX_BUF] = {0};
for (int i = 0; i < cpuinfo.number; ++i)
{
sigar_cpu_info_t *info = &cpuinfo.data[i];
sprintf(line, "CPU %d:\n", i+1);
mMyStream<<line;
#define CPU_FORMAT_STR(field) \
sprintf(line, "%16s: %s\n", #field, info->field); \
mMyStream<<line; \
#define CPU_FORMAT_INT(field) \
sprintf(line, "%16s: %d\n", #field, info->field); \
mMyStream<<line; \
#define CPU_FORMAT_INT64(field) \
sprintf(line, "%16s: %llu\n", #field, info->field); \
mMyStream<<line; \
CPU_FORMAT_STR(vendor);
CPU_FORMAT_STR(model);
CPU_FORMAT_INT(mhz);
CPU_FORMAT_INT(mhz_max);
CPU_FORMAT_INT(mhz_min);
CPU_FORMAT_INT64(cache_size);
CPU_FORMAT_INT(total_sockets);
CPU_FORMAT_INT(total_cores);
CPU_FORMAT_INT(cores_per_socket);
mMyStream<<"\n";
}
sigar_cpu_info_list_destroy(s, &cpuinfo);
sigar_close(s);
return 0;
}
//-------------------------------------------------------------------------------------
void SystemInfo::clear()
{
if(_g_sigarproclist)
{
sigar_proc_list_destroy(_g_sigarproclist, &_g_proclist);
sigar_close(_g_sigarproclist);
_g_sigarproclist = NULL;
}
if(_g_sigar_cpu)
{
sigar_close(_g_sigar_cpu);
_g_sigar_cpu = NULL;
}
}
//-------------------------------------------------------------------------------------
uint32 SystemInfo::countCPU()
{
static uint32 count = 0;
if(count == 0)
{
int status = SIGAR_OK;
sigar_t *sigarcpulist;
sigar_cpu_list_t cpulist;
sigar_open(&sigarcpulist);
status = sigar_cpu_list_get(sigarcpulist, &cpulist);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("error: {} ({}) cpu_list_get\n",
status, sigar_strerror(sigarcpulist, status)));
count = 1;
}
else
{
count = cpulist.number;
sigar_cpu_list_destroy(sigarcpulist, &cpulist);
}
sigar_close(sigarcpulist);
}
return count;
}
Mem::Mem()
{
int status;
sigar_t *sigar;
sigar_mem_t mem;
sigar_open(&sigar);
status = sigar_mem_get(sigar, &mem);
if (status != SIGAR_OK) {
printf("get mem info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
ram.setNum(mem.ram);
total.setNum(mem.total / MiB, 'g');
used.setNum(mem.used / MiB, 'g');
free.setNum(mem.free / MiB, 'g');
actual_free.setNum(mem.actual_free / MiB, 'g');
actual_used.setNum(mem.actual_used / MiB, 'g');
actual_free_percent.setNum(mem.free_percent, 'g');
actual_used_percent.setNum(mem.used_percent, 'g');
qDebug() << "mem.actual_used : " << mem.actual_used;
qDebug() << "mem.used_percent : " << mem.used_percent;
qDebug() << "actual_used_percent : " << actual_used_percent;
sigar_close(sigar);
}
NetRouteInfo::NetRouteInfo()
{
sigar_t *sigar_route;
sigar_net_route_list_t route_list;
sigar_open(&sigar_route);
int status = sigar_net_route_list_get(sigar_route,&route_list);
if(status != SIGAR_OK)
cout<<"Net Route Error: "<<status<<sigar_strerror(sigar_route,status);
for(int i=0; i<route_list.number; i++)
{
sigar_net_route_t route = route_list.data[i];
cout<<route.mask.addr.in<<endl;
}
sigar_net_route_list_destroy(sigar_route,&route_list);
sigar_close(sigar_route);
}
Uptime::Uptime() {
QString cpu;
int status;
char b[256];
sigar_t *sigar;
sigar_uptime_t uptime;
sigar_open(&sigar);
status = sigar_uptime_get(sigar, &uptime);
status = sigar_uptime_string(sigar, &uptime, b, sizeof(b));
if (status != SIGAR_OK) {
printf("get uptime error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
this->time = cpu.setNum(uptime.uptime, 'g');
//this->time = uptime.uptime;
this->days = b;
qDebug() << "uptime.uptime : " << uptime.uptime;
qDebug() << "time : " << this->time;
//printf("uptime time %f\n", uptime.uptime);
//printf("uptime days = %s time %f\n", b, uptime.uptime);
sigar_close(sigar);
}
JNIEXPORT jint SIGAR_JNIx(nativeClose)
(JNIEnv *env, jobject sigar_obj)
{
jint status;
int i;
dSIGAR(0);
/* only place it is possible this would be something other than
* SIGAR_OK is on win32 if RegCloseKey fails, which i don't think
* is possible either.
*/
status = sigar_close(sigar);
if (jsigar->logger != NULL) {
JENV->DeleteGlobalRef(env, jsigar->logger);
}
if (jsigar->not_impl != NULL) {
JENV->DeleteGlobalRef(env, jsigar->not_impl);
}
for (i=0; i<JSIGAR_FIELDS_MAX; i++) {
if (jsigar->fields[i]) {
JENV->DeleteGlobalRef(env,
jsigar->fields[i]->classref);
free(jsigar->fields[i]->ids);
free(jsigar->fields[i]);
}
}
free(jsigar);
sigar_set_pointer(env, sigar_obj, NULL);
return status;
}
static int lua_sigar_free(lua_State *L) {
sigar_t *s = *(sigar_t **)luaL_checkudata(L, 1, "sigar");
sigar_close(s);
return 0;
}
SysInfo::SysInfo()
{
int status;
sigar_t *sigar;
sigar_sys_info_t sysinfo;
sigar_open(&sigar);
status = sigar_sys_info_get(sigar, &sysinfo);
if (status != SIGAR_OK) {
printf("get sys info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
name = sysinfo.name;
version = sysinfo.version;
arch = sysinfo.arch;
machine = sysinfo.machine;
description = sysinfo.description;
patch_level = sysinfo.patch_level;
vendor = sysinfo.vendor;
vendor_version = sysinfo.vendor_version;
vendor_name = sysinfo.vendor_name;
vendor_code_name = sysinfo.vendor_code_name;
sigar_close(sigar);
}
void
test_cpu_info(void) {
//int status, i;
sigar_t *sigar;
//sigar_cpu_list_t cpulist;
sigar_open(&sigar);
sigar_cpu_info_list_t cpu_info_list;
sigar_cpu_info_list_get(sigar, &cpu_info_list);
//sigar_cpu_info_t cpu_info = cup_info_list;
printf("vendor......%s\n", cpu_info_list.data->vendor);
printf("model......%s\n", cpu_info_list.data->model);
printf("mhz......%d\n", cpu_info_list.data->mhz);
printf("total cores......%d\n", cpu_info_list.data->total_cores);
//printf("Vendor......%s\n", cpu_info->vendor);
sigar_cpu_info_list_destroy(sigar, &cpu_info_list);
sigar_cpu_t cpu_old;
sigar_cpu_t cpu_cur;
sigar_cpu_get(sigar, &cpu_old);
sigar_cpu_perc_t perc;
sleep(1);
sigar_cpu_get(sigar, &cpu_cur);
sigar_cpu_perc_calculate(&cpu_old, &cpu_cur, &perc);
printf("user......%3.2f%%\n", perc.user * 100);
printf("sys......%3.2f%%\n", perc.sys * 100);
printf("wait......%3.2f%%\n", perc.wait * 100);
printf("nice......%3.2f%%\n", perc.nice * 100);
printf("irq time......%f\n", perc.irq);
printf("total used rate......%3.2f%%\n", perc.combined * 100);
printf("total idle rate......%3.2f%%\n", perc.idle * 100);
cpu_old = cpu_cur;
/*
status = sigar_cpu_list_get(sigar, &cpulist);
if (status != SIGAR_OK) {
printf("cpu_list error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
for (i=0; i<cpulist.number; i++) {
sigar_cpu_t cpu = cpulist.data[i];
printf("cpu user: %ld, sys: %ld, nice: %ld, idle: %ld, wait: %ld, irq: %ld, soft_irq: %ld, stolen: %ld, total: %ld.\n",
cpu.user, cpu.sys, cpu.nice, cpu.idle, cpu.wait, cpu.irq, cpu.soft_irq, cpu.stolen, cpu.total);
}
sigar_cpu_list_destroy(sigar, &cpulist);
*/
sigar_close(sigar);
}
int main() {
sigar_t *t;
assert(SIGAR_OK == sigar_open(&t));
test_sigar_pid_get(t);
sigar_close(t);
return 0;
}
int main() {
sigar_t *t;
int err = 0;
assert(SIGAR_OK == sigar_open(&t));
test_sigar_mem_get(t);
sigar_close(t);
return err ? -1 : 0;
}
//-------------------------------------------------------------------------------------
SystemInfo::MEM_INFOS SystemInfo::getMemInfos()
{
MEM_INFOS infos;
sigar_t *sigar;
sigar_open(&sigar);
sigar_mem_t sigar_mem;
sigar_mem_get(sigar, &sigar_mem);
infos.total = sigar_mem.total;
infos.free = sigar_mem.actual_free;
infos.used = sigar_mem.actual_used;
sigar_close(sigar);
return infos;
}
NetInfo::NetInfo()
{
int status;
sigar_t *sigar;
sigar_net_info_t ni;
sigar_net_interface_config_t ifc;
char addrbuf[SIGAR_INET6_ADDRSTRLEN];
sigar_open(&sigar);
status = sigar_net_info_get(sigar, &ni);
if (status != SIGAR_OK) {
printf("get net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
hostname = ni.host_name;
default_gateway = ni.default_gateway;
domain_name = ni.domain_name;
primary_dns = ni.primary_dns;
secondary_dns = ni.secondary_dns;
status = sigar_net_interface_config_primary_get(sigar, &ifc);
if (status != SIGAR_OK) {
printf("get net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
if (sigar_net_interface_config_primary_get(sigar, &ifc) == SIGAR_OK) {
primary_interface = ifc.name;
sigar_net_address_to_string(sigar, &ifc.address, addrbuf);
primary_addr = addrbuf;
}
if (primary_addr.isEmpty() )
primary_addr = "127.0.0.1";
qDebug () << ifc.name << " " << ifc.type << " " << primary_addr;
sigar_close(sigar);
}
LoadAvg::LoadAvg()
{
// loadavg doest not exist on windows. Test to not segfault
if (system.os_name.indexOf("windows", 0, Qt::CaseInsensitive) == -1) {
QString load;
int status;
sigar_t *sigar;
sigar_loadavg_t loadavg;
sigar_open(&sigar);
status = sigar_loadavg_get(sigar, &loadavg);
if (status != SIGAR_OK) {
printf("get load avg : %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
qDebug() << "loadavg.loadavg[0] : " << loadavg.loadavg[0];
qDebug() << "loadavg.loadavg[1] : " << loadavg.loadavg[1];
qDebug() << "loadavg.loadavg[2] : " << loadavg.loadavg[2];
/*
int i_loadavg0 = loadavg.loadavg[0] * 100.00 + 0.5;
int i_loadavg1 = loadavg.loadavg[1] * 100.00 + 0.5;
int i_loadavg2 = loadavg.loadavg[2] * 100.00 + 0.5;
loadavg0 = load.setNum(i_loadavg0);
loadavg1 = load.setNum(i_loadavg1);
loadavg2 = load.setNum(i_loadavg2);
*/
loadavg0 = load.setNum(loadavg.loadavg[0], 'g');
loadavg1 = load.setNum(loadavg.loadavg[1], 'g');
loadavg2 = load.setNum(loadavg.loadavg[2], 'g');
sigar_close(sigar);
}
}
CpuStat::CpuStat()
{
int status, i;
sigar_t *sigar;
sigar_cpu_t _prev_cpu, cpu;
sigar_cpu_perc_t cpu_perc;
sigar_open(&sigar);
status = sigar_cpu_get(sigar, &_prev_cpu);
if (status != SIGAR_OK) {
printf("cpu stat error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
QTest::qSleep(1000);
status = sigar_cpu_get(sigar, &cpu);
if (status != SIGAR_OK) {
printf("cpu stat error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
sigar_cpu_perc_calculate(&_prev_cpu, &cpu, &cpu_perc);
user.setNum(cpu_perc.user * 100.);
sys.setNum(cpu_perc.sys * 100.);
nice.setNum(cpu_perc.nice * 100.);
idle.setNum(cpu_perc.idle * 100.);
wait.setNum(cpu_perc.wait * 100.);
irq.setNum(cpu_perc.irq * 100.);
soft_irq.setNum(cpu_perc.soft_irq * 100.);
stolen.setNum(cpu_perc.stolen * 100.);
combined.setNum(cpu_perc.combined * 100.);
total.setNum(cpu.total);
sigar_close(sigar);
}
//-------------------------------------------------------------------------------------
bool SystemInfo::_autocreate()
{
if(_g_sigarproclist == NULL)
{
sigar_open(&_g_sigarproclist);
int status = sigar_proc_list_get(_g_sigarproclist, &_g_proclist);
if (status != SIGAR_OK)
{
DEBUG_MSG(fmt::format("SystemInfo::autocreate:error: {} ({}) sigar_proc_list_get\n",
status, sigar_strerror(_g_sigarproclist, status)));
sigar_close(_g_sigarproclist);
_g_sigarproclist = NULL;
return false;
}
}
return true;
}
Json::Value DiskSensor::GetMetaData() const
{
Json::Value metaData;
sigar_t *fileSystem;
sigar_open(&fileSystem);
sigar_file_system_list_t fsList;
sigar_file_system_list_get(fileSystem, &fsList);
std::set<std::string> devices;
for(int i=0;i<fsList.number;i++)
{
if(boost::starts_with(fsList.data[i].dev_name, "/dev/sd") || boost::starts_with(fsList.data[i].dev_name, "/dev/hd"))
{
devices.insert(fsList.data[i].dev_name);
}
}
sigar_close(fileSystem);
for(auto it=devices.begin();it!= devices.end();it++)
{
std::cout << *it << " " << std::endl;
}
return metaData;
}
Cpu::Cpu() {
int status, i;
sigar_t *sigar;
sigar_cpu_info_list_t cpulist;
sigar_open(&sigar);
status = sigar_cpu_info_list_get(sigar, &cpulist);
if (status != SIGAR_OK) {
printf("cpu_list error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
/*
for (i=0; i<cpulist.number; i++) {
sigar_cpu_info_t cpu = cpulist.data[i];
cpus << cpu.vendor;
cpus << cpu.model;
cpus << cpu.mhz;
cpus << cpu.cache_size;
}*/
sigar_cpu_info_t cpu = cpulist.data[0];
vendor = cpu.vendor;
model = cpu.model;
mhz.setNum(cpu.mhz);
cache_size.setNum(cpu.cache_size);
number.setNum(cpulist.number);
total_cores.setNum(cpu.total_cores);
total_sockets.setNum(cpu.total_sockets);
cores_per_socket.setNum(cpu.cores_per_socket);
sigar_cpu_info_list_destroy(sigar, &cpulist);
sigar_close(sigar);
}
Swap::Swap()
{
int status;
sigar_t *sigar;
sigar_swap_t swap;
sigar_open(&sigar);
status = sigar_swap_get(sigar, &swap);
if (status != SIGAR_OK) {
printf("get swap info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
total.setNum(swap.total / MiB, 'g');
used.setNum(swap.used / MiB, 'g');
free.setNum(swap.free / MiB, 'g');
page_in.setNum(swap.page_in);
page_out.setNum(swap.page_out);
sigar_close(sigar);
}
NetConnectionInfo::NetConnectionInfo()
{
sigar_t *sigar_conn;
sigar_net_connection_list_t conn_list;
sigar_open(&sigar_conn);
int flags = SIGAR_NETCONN_SERVER | SIGAR_NETCONN_CLIENT | SIGAR_NETCONN_TCP | SIGAR_NETCONN_UDP ;
int status = sigar_net_connection_list_get(sigar_conn,&conn_list,flags);
if(status != SIGAR_OK)
cout<<"Net Connection Error: "<<status<<sigar_strerror(sigar_conn,status);
for(int i=0; i<conn_list.number; i++)
{
sigar_net_connection_t conn = conn_list.data[i];
}
sigar_net_connection_list_destroy(sigar_conn,&conn_list);
sigar_close(sigar_conn);
}
ZSystemInfo::~ZSystemInfo(){
sigar_close(_sigar);
}
static void rb_sigar_close(void *obj)
{
sigar_close((sigar_t *)obj);
}
static void rb_sigar_close(rb_sigar_t *rbsigar)
{
sigar_close(rbsigar->sigar);
rb_sigar_free(rbsigar);
}
void cpu_info_destroy(CPUInfo* info) {
sigar_cpu_info_list_destroy(info->sigar, info->cpu_info_list);
sigar_close(info->sigar);
cJSON_Delete(info->json);
free(info);
}
ProcList::ProcList()
{
int status;
sigar_t *sigar;
sigar_proc_list_t proclist;
unsigned long i;
sigar_open(&sigar);
status = sigar_proc_list_get(sigar, &proclist);
if (status != SIGAR_OK) {
printf("get proc list error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
for (i=0; i<proclist.number; i++) {
sigar_pid_t pid = proclist.data[i];
sigar_proc_mem_t proc_mem;
sigar_proc_time_t proc_time;
sigar_proc_state_t proc_state;
status = sigar_proc_mem_get(sigar, pid, &proc_mem);
if (status != SIGAR_OK) {
#ifdef DEBUG
printf("error: %d (%s) proc_mem(%d)\n",
status, sigar_strerror(sigar, status), pid);
#endif
continue;
}
status = sigar_proc_state_get(sigar, pid, &proc_state);
if (status != SIGAR_OK) {
#ifdef DEBUG
printf("error: %d (%s) proc_state(%d)\n",
status, sigar_strerror(sigar, status), pid);
#endif
continue;
}
status = sigar_proc_time_get(sigar, pid, &proc_time);
if (status != SIGAR_OK) {
#ifdef DEBUG
printf("error: %d (%s) proc_time(%d)\n",
status, sigar_strerror(sigar, status), pid);
#endif
continue;
}
// printf("%d %s\n", (long)pid, pstate.name);
//qDebug() << "name " << pstate.name << " processor " << pstate.processor;
//qDebug() << lpid.setNum((long)pid);
// datas << QString("PID : %1 , %2").arg(lpid.setNum((long)pid), pstate.name);
Process proc;
//proc = new(Process);
proc.pid.setNum((long)pid);
proc.state_name = proc_state.name;
proc.state_state = proc_state.state;
proc.state_ppid.setNum(proc_state.ppid);
//proc.state_tty = proc_state.tty;
proc.state_priority.setNum(proc_state.priority);
proc.state_nice.setNum(proc_state.nice);
proc.state_processor.setNum(proc_state.processor);
proc.state_threads.setNum(proc_state.threads);
proc.mem_size.setNum(proc_mem.size);
proc.mem_resident.setNum(proc_mem.resident);
proc.mem_share.setNum(proc_mem.share);
proc.mem_minor_faults.setNum(proc_mem.minor_faults);
proc.mem_major_faults.setNum(proc_mem.major_faults);
proc.mem_page_faults.setNum(proc_mem.page_faults);
proc.time_start_time.setNum(proc_time.start_time);
qDebug() << "proc_state.name : " << proc_state.name << " : proc_time.start_time : " << proc_time.start_time;
proc.time_user.setNum(proc_time.user);
proc.time_sys.setNum(proc_time.sys);
proc.time_total.setNum(proc_time.total);
stack.push(proc);
//delete(proc);
}
/* TEST OK
while (!stack.isEmpty())
{
qDebug() << "stack length : " << stack.count();
ok = .pop();
qDebug() << "name : " << ok->state_name << " " << " pid : " << ok->pid;
delete(ok);
}
*/
sigar_proc_list_destroy(sigar, &proclist);
sigar_close(sigar);
}
NetStat::NetStat(QString ifname)
{
int status;
QString tmp;
sigar_t *sigar;
sigar_net_stat_t s;
sigar_net_interface_stat_t curr, curr2;
sigar_open(&sigar);
status = sigar_net_stat_get(sigar, &s, DEFAULT_NET_STAT_FLAGS);
if (status != SIGAR_OK) {
printf("get net start info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
/*
s.all_inbound_total;
s.all_outbound_total;
s.tcp_inbound_total;
s.tcp_outbound_total;
s.tcp_states;*/
tcp_established = s.tcp_states[SIGAR_TCP_ESTABLISHED];
tcp_listen = s.tcp_states[SIGAR_TCP_LISTEN];
tcp_time_wait = s.tcp_states[SIGAR_TCP_TIME_WAIT];
tcp_close_wait = s.tcp_states[SIGAR_TCP_CLOSE_WAIT];
tcp_idle = s.tcp_states[SIGAR_TCP_IDLE];
status = sigar_net_interface_stat_get(sigar, ifname.toAscii(), &curr);
if (status != SIGAR_OK) {
printf("get stat net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
// printf("curr_net_stat: rx_bytes=%llu, tx_bytes=%llu \n", (Llu)curr.rx_bytes, (Llu)curr.tx_bytes);
m_time.start();
//poll(0, 0, DEFAULT_PAUSE);
QTest::qSleep(1000);
status = sigar_net_interface_stat_get(sigar, ifname.toAscii(), &curr2);
if (status != SIGAR_OK) {
printf("get stat net info error: %d (%s)\n",
status, sigar_strerror(sigar, status));
exit(1);
}
int elapsed = m_time.elapsed();
//rx_bytes.setNum(curr.rx_bytes, 10);
//tx_bytes.setNum(curr.tx_bytes, 10);
//double tmp = (curr2.rx_bytes - curr.rx_bytes) / KiB;
//qDebug() << "rx tmp " << tmp;
rx_rate.setNum(((curr2.rx_bytes - curr.rx_bytes) / KiB), 'g');
//rx_rate = (curr2.rx_bytes - curr.rx_bytes) / KiB;
//tmp = "";
//tmp = (curr2.tx_bytes - curr.tx_bytes) / KiB;
//qDebug() << "tx tmp " << tmp;
tx_rate.setNum(((curr2.tx_bytes - curr.tx_bytes) / KiB), 'g');
//tx_rate = (curr2.tx_bytes - curr.tx_bytes) / KiB;
//tmp = "";
qDebug() << "tx2 rate : " << curr2.tx_bytes << " tx rate : " << curr.tx_bytes << " rate : " << (curr2.tx_bytes - curr.tx_bytes) / KiB;
sigar_close(sigar);
}
