Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

2445 lines (2032 sloc) 64.365 kb
/*
* Copyright (c) 2004-2009 Hyperic, Inc.
* Copyright (c) 2009 SpringSource, Inc.
* Copyright (c) 2009-2010 VMware, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <errno.h>
#include <stdio.h>
#ifndef WIN32
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#endif
#if defined(__OpenBSD__) || defined(__FreeBSD__)
#include <netinet/in.h>
#endif
#ifndef WIN32
#include <arpa/inet.h>
#endif
#if defined(HAVE_UTMPX_H)
# include <utmpx.h>
#elif defined(HAVE_UTMP_H)
# include <utmp.h>
#endif
#include "sigar.h"
#include "sigar_private.h"
#include "sigar_util.h"
#include "sigar_os.h"
#include "sigar_format.h"
SIGAR_DECLARE(int) sigar_open(sigar_t **sigar)
{
int status = sigar_os_open(sigar);
if (status == SIGAR_OK) {
/* use env to revert to old behavior */
(*sigar)->cpu_list_cores = getenv("SIGAR_CPU_LIST_SOCKETS") ? 0 : 1;
(*sigar)->pid = 0;
(*sigar)->ifconf_buf = NULL;
(*sigar)->ifconf_len = 0;
(*sigar)->log_level = -1; /* log nothing by default */
(*sigar)->log_impl = NULL;
(*sigar)->log_data = NULL;
(*sigar)->ptql_re_impl = NULL;
(*sigar)->ptql_re_data = NULL;
(*sigar)->self_path = NULL;
(*sigar)->fsdev = NULL;
(*sigar)->pids = NULL;
(*sigar)->proc_cpu = NULL;
(*sigar)->net_listen = NULL;
(*sigar)->net_services_tcp = NULL;
(*sigar)->net_services_udp = NULL;
(*sigar)->proc_io = NULL;
}
return status;
}
SIGAR_DECLARE(int) sigar_close(sigar_t *sigar)
{
if (sigar->ifconf_buf) {
free(sigar->ifconf_buf);
}
if (sigar->self_path) {
free(sigar->self_path);
}
if (sigar->pids) {
sigar_proc_list_destroy(sigar, sigar->pids);
free(sigar->pids);
}
if (sigar->fsdev) {
sigar_cache_destroy(sigar->fsdev);
}
if (sigar->proc_cpu) {
sigar_cache_destroy(sigar->proc_cpu);
}
if (sigar->net_listen) {
sigar_cache_destroy(sigar->net_listen);
}
if (sigar->net_services_tcp) {
sigar_cache_destroy(sigar->net_services_tcp);
}
if (sigar->net_services_udp) {
sigar_cache_destroy(sigar->net_services_udp);
}
if (sigar->proc_io) {
sigar_cache_destroy(sigar->proc_io);
}
return sigar_os_close(sigar);
}
#ifndef __linux__ /* linux has a special case */
SIGAR_DECLARE(sigar_pid_t) sigar_pid_get(sigar_t *sigar)
{
if (!sigar->pid) {
sigar->pid = getpid();
}
return sigar->pid;
}
#endif
/* XXX: add clear() function */
/* XXX: check for stale-ness using start_time */
SIGAR_DECLARE(int) sigar_proc_cpu_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_cpu_t *proccpu)
{
sigar_cache_entry_t *entry;
sigar_proc_cpu_t *prev;
sigar_uint64_t otime, time_now = sigar_time_now_millis();
sigar_uint64_t time_diff, total_diff;
int status;
if (!sigar->proc_cpu) {
sigar->proc_cpu = sigar_expired_cache_new(128, PID_CACHE_CLEANUP_PERIOD, PID_CACHE_ENTRY_EXPIRE_PERIOD);
}
entry = sigar_cache_get(sigar->proc_cpu, pid);
if (entry->value) {
prev = (sigar_proc_cpu_t *)entry->value;
}
else {
prev = entry->value = malloc(sizeof(*prev));
SIGAR_ZERO(prev);
}
time_diff = time_now - prev->last_time;
proccpu->last_time = prev->last_time = time_now;
if (time_diff == 0) {
/* we were just called within < 1 second ago. */
memcpy(proccpu, prev, sizeof(*proccpu));
return SIGAR_OK;
}
otime = prev->total;
status =
sigar_proc_time_get(sigar, pid,
(sigar_proc_time_t *)proccpu);
if (status != SIGAR_OK) {
return status;
}
memcpy(prev, proccpu, sizeof(*prev));
if (proccpu->total < otime) {
/* XXX this should not happen */
otime = 0;
}
if (otime == 0) {
proccpu->percent = 0.0;
/* first time called */
return SIGAR_OK;
}
total_diff = proccpu->total - otime;
proccpu->percent = total_diff / (double)time_diff;
return SIGAR_OK;
}
void copy_cached_disk_io_into_disk_io( sigar_cached_proc_disk_io_t *cached, sigar_proc_disk_io_t *proc_disk_io) {
proc_disk_io->bytes_read = cached->bytes_read_diff;
proc_disk_io->bytes_written = cached->bytes_written_diff;
proc_disk_io->bytes_total = cached->bytes_total_diff;
}
sigar_uint64_t get_io_diff(sigar_uint64_t current_value, sigar_uint64_t prev_value, sigar_uint64_t time_diff) {
double io_diff;
sigar_uint64_t int_io_diff;
if ( current_value == SIGAR_FIELD_NOTIMPL ) {
return SIGAR_FIELD_NOTIMPL;
}
io_diff = (( current_value - prev_value)/(double)time_diff)*SIGAR_MSEC;
int_io_diff = (sigar_uint64_t)io_diff;
if (int_io_diff >=0) {
return int_io_diff;
}
return 0;
}
void calculate_io_diff(sigar_proc_cumulative_disk_io_t * proc_disk_io, sigar_cached_proc_disk_io_t *cached, sigar_uint64_t time_diff, int is_first_time) {
/*calculate avg diff /read/write/total per second*/
if (!is_first_time) {
cached->bytes_written_diff = get_io_diff(proc_disk_io->bytes_written, cached->bytes_written, time_diff);
cached->bytes_read_diff = get_io_diff(proc_disk_io->bytes_read, cached->bytes_read, time_diff);
cached->bytes_total_diff = get_io_diff(proc_disk_io->bytes_total, cached->bytes_total, time_diff);
}
else {
cached->bytes_total_diff = cached->bytes_read_diff = cached->bytes_written_diff = 0.0;
}
// now put in cache the current cumulative values
cached->bytes_written = proc_disk_io->bytes_written;
cached->bytes_read = proc_disk_io->bytes_read;
cached->bytes_total = proc_disk_io->bytes_total;
}
SIGAR_DECLARE(int) sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_disk_io_t *proc_disk_io)
{
sigar_cache_entry_t *entry;
sigar_cached_proc_disk_io_t *prev;
sigar_proc_cumulative_disk_io_t cumulative_proc_disk_io;
sigar_uint64_t time_now = sigar_time_now_millis();
sigar_uint64_t time_diff;
int status, is_first_time;
if (!sigar->proc_io) {
sigar->proc_io = sigar_expired_cache_new(128, PID_CACHE_CLEANUP_PERIOD, PID_CACHE_ENTRY_EXPIRE_PERIOD);
}
entry = sigar_cache_get(sigar->proc_io, pid);
if (entry->value) {
prev = (sigar_cached_proc_disk_io_t *)entry->value;
}
else {
prev = entry->value = malloc(sizeof(*prev));
SIGAR_ZERO(prev);
}
is_first_time = (prev->last_time == 0);
time_diff = time_now - prev->last_time;
if (time_diff < 1000) {
/* we were just called within < 1 second ago. */
copy_cached_disk_io_into_disk_io(prev, proc_disk_io);
if (time_diff < 0) {
// something is wrong at least from now on the time will be ok
prev->last_time = time_now;
}
return SIGAR_OK;
}
prev->last_time = time_now;
status =
sigar_proc_cumulative_disk_io_get(sigar, pid,
&cumulative_proc_disk_io);
if (status != SIGAR_OK) {
return status;
}
calculate_io_diff(&cumulative_proc_disk_io, prev, time_diff, is_first_time);
copy_cached_disk_io_into_disk_io(prev, proc_disk_io);
return SIGAR_OK;
}
void get_cache_info(sigar_cache_t * cache, char * name){
if (cache == NULL) {
return;
}
printf("******** %s *********\n", name);
sigar_cache_dump(cache);
}
SIGAR_DECLARE(int) sigar_dump_pid_cache_get(sigar_t *sigar, sigar_dump_pid_cache_t *info) {
get_cache_info(sigar->proc_cpu, "proc cpu cache");
get_cache_info(sigar->proc_io, "proc io cache");
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_proc_stat_get(sigar_t *sigar,
sigar_proc_stat_t *procstat)
{
int status, i;
sigar_proc_list_t *pids;
SIGAR_ZERO(procstat);
procstat->threads = SIGAR_FIELD_NOTIMPL;
if ((status = sigar_proc_list_get(sigar, NULL)) != SIGAR_OK) {
return status;
}
pids = sigar->pids;
procstat->total = pids->number;
for (i=0; i<pids->number; i++) {
sigar_proc_state_t state;
status = sigar_proc_state_get(sigar, pids->data[i], &state);
if (status != SIGAR_OK) {
continue;
}
if (state.threads != SIGAR_FIELD_NOTIMPL) {
procstat->threads += state.threads;
}
switch (state.state) {
case SIGAR_PROC_STATE_IDLE:
procstat->idle++;
break;
case SIGAR_PROC_STATE_RUN:
procstat->running++;
break;
case SIGAR_PROC_STATE_SLEEP:
procstat->sleeping++;
break;
case SIGAR_PROC_STATE_STOP:
procstat->stopped++;
break;
case SIGAR_PROC_STATE_ZOMBIE:
procstat->zombie++;
break;
default:
break;
}
}
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_sys_info_get(sigar_t *sigar,
sigar_sys_info_t *sysinfo)
{
SIGAR_ZERO(sysinfo);
#ifndef WIN32
sigar_sys_info_get_uname(sysinfo);
#endif
sigar_os_sys_info_get(sigar, sysinfo);
return SIGAR_OK;
}
#ifndef WIN32
#include <sys/utsname.h>
int sigar_sys_info_get_uname(sigar_sys_info_t *sysinfo)
{
struct utsname name;
uname(&name);
SIGAR_SSTRCPY(sysinfo->version, name.release);
SIGAR_SSTRCPY(sysinfo->vendor_name, name.sysname);
SIGAR_SSTRCPY(sysinfo->name, name.sysname);
SIGAR_SSTRCPY(sysinfo->machine, name.machine);
SIGAR_SSTRCPY(sysinfo->arch, name.machine);
SIGAR_SSTRCPY(sysinfo->patch_level, "unknown");
return SIGAR_OK;
}
SIGAR_DECLARE(int)
sigar_proc_cred_name_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_cred_name_t *proccredname)
{
sigar_proc_cred_t cred;
int status = sigar_proc_cred_get(sigar, pid, &cred);
if (status != SIGAR_OK) {
return status;
}
status = sigar_user_name_get(sigar, cred.uid,
proccredname->user,
sizeof(proccredname->user));
if (status != SIGAR_OK) {
return status;
}
status = sigar_group_name_get(sigar, cred.gid,
proccredname->group,
sizeof(proccredname->group));
return status;
}
#endif /* WIN32 */
int sigar_proc_list_create(sigar_proc_list_t *proclist)
{
proclist->number = 0;
proclist->size = SIGAR_PROC_LIST_MAX;
proclist->data = malloc(sizeof(*(proclist->data)) *
proclist->size);
return SIGAR_OK;
}
int sigar_proc_list_grow(sigar_proc_list_t *proclist)
{
proclist->data = realloc(proclist->data,
sizeof(*(proclist->data)) *
(proclist->size + SIGAR_PROC_LIST_MAX));
proclist->size += SIGAR_PROC_LIST_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_proc_list_destroy(sigar_t *sigar,
sigar_proc_list_t *proclist)
{
if (proclist->size) {
free(proclist->data);
proclist->number = proclist->size = 0;
}
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_proc_list_get(sigar_t *sigar,
sigar_proc_list_t *proclist)
{
if (proclist == NULL) {
/* internal re-use */
if (sigar->pids == NULL) {
sigar->pids = malloc(sizeof(*sigar->pids));
sigar_proc_list_create(sigar->pids);
}
else {
sigar->pids->number = 0;
}
proclist = sigar->pids;
}
else {
sigar_proc_list_create(proclist);
}
return sigar_os_proc_list_get(sigar, proclist);
}
int sigar_proc_args_create(sigar_proc_args_t *procargs)
{
procargs->number = 0;
procargs->size = SIGAR_PROC_ARGS_MAX;
procargs->data = malloc(sizeof(*(procargs->data)) *
procargs->size);
return SIGAR_OK;
}
int sigar_proc_args_grow(sigar_proc_args_t *procargs)
{
procargs->data = realloc(procargs->data,
sizeof(*(procargs->data)) *
(procargs->size + SIGAR_PROC_ARGS_MAX));
procargs->size += SIGAR_PROC_ARGS_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_proc_args_destroy(sigar_t *sigar,
sigar_proc_args_t *procargs)
{
unsigned int i;
if (procargs->size) {
for (i=0; i<procargs->number; i++) {
free(procargs->data[i]);
}
free(procargs->data);
procargs->number = procargs->size = 0;
}
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_proc_args_get(sigar_t *sigar,
sigar_pid_t pid,
sigar_proc_args_t *procargs)
{
int status;
sigar_proc_args_create(procargs);
status = sigar_os_proc_args_get(sigar, pid, procargs);
if (status != SIGAR_OK) {
sigar_proc_args_destroy(sigar, procargs);
}
return status;
}
int sigar_file_system_list_create(sigar_file_system_list_t *fslist)
{
fslist->number = 0;
fslist->size = SIGAR_FS_MAX;
fslist->data = malloc(sizeof(*(fslist->data)) *
fslist->size);
return SIGAR_OK;
}
int sigar_file_system_list_grow(sigar_file_system_list_t *fslist)
{
fslist->data = realloc(fslist->data,
sizeof(*(fslist->data)) *
(fslist->size + SIGAR_FS_MAX));
fslist->size += SIGAR_FS_MAX;
return SIGAR_OK;
}
/* indexed with sigar_file_system_type_e */
static const char *fstype_names[] = {
"unknown", "none", "local", "remote", "ram", "cdrom", "swap"
};
static int sigar_common_fs_type_get(sigar_file_system_t *fsp)
{
char *type = fsp->sys_type_name;
switch (*type) {
case 'n':
if (strnEQ(type, "nfs", 3)) {
fsp->type = SIGAR_FSTYPE_NETWORK;
}
break;
case 's':
if (strEQ(type, "smbfs")) { /* samba */
fsp->type = SIGAR_FSTYPE_NETWORK;
}
else if (strEQ(type, "swap")) {
fsp->type = SIGAR_FSTYPE_SWAP;
}
break;
case 'a':
if (strEQ(type, "afs")) {
fsp->type = SIGAR_FSTYPE_NETWORK;
}
break;
case 'i':
if (strEQ(type, "iso9660")) {
fsp->type = SIGAR_FSTYPE_CDROM;
}
break;
case 'c':
if (strEQ(type, "cvfs")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
else if (strEQ(type, "cifs")) {
fsp->type = SIGAR_FSTYPE_NETWORK;
}
break;
case 'm':
if (strEQ(type, "msdos") || strEQ(type, "minix")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
break;
case 'h':
if (strEQ(type, "hpfs")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
break;
case 'v':
if (strEQ(type, "vxfs")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
else if (strEQ(type, "vfat")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
break;
case 'z':
if (strEQ(type, "zfs")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
break;
}
return fsp->type;
}
void sigar_fs_type_get(sigar_file_system_t *fsp)
{
if (!(fsp->type || /* already set */
sigar_os_fs_type_get(fsp) || /* try os specifics first */
sigar_common_fs_type_get(fsp))) /* try common ones last */
{
fsp->type = SIGAR_FSTYPE_NONE;
}
if (fsp->type >= SIGAR_FSTYPE_MAX) {
fsp->type = SIGAR_FSTYPE_NONE;
}
strcpy(fsp->type_name, fstype_names[fsp->type]);
}
SIGAR_DECLARE(int)
sigar_file_system_list_destroy(sigar_t *sigar,
sigar_file_system_list_t *fslist)
{
if (fslist->size) {
free(fslist->data);
fslist->number = fslist->size = 0;
}
return SIGAR_OK;
}
#ifndef NFS_PROGRAM
#define NFS_PROGRAM 100003
#endif
#ifndef NFS_VERSION
#define NFS_VERSION 2
#endif
SIGAR_DECLARE(int)
sigar_file_system_ping(sigar_t *sigar,
sigar_file_system_t *fs)
{
int status = SIGAR_OK;
#ifndef WIN32
char *ptr;
if ((fs->type == SIGAR_FSTYPE_NETWORK) &&
strEQ(fs->sys_type_name, "nfs") &&
(ptr = strchr(fs->dev_name, ':')))
{
*ptr = '\0'; /* "hostname:/mount" -> "hostname" */
status = sigar_rpc_ping(fs->dev_name,
SIGAR_NETCONN_UDP,
NFS_PROGRAM, NFS_VERSION);
if (SIGAR_LOG_IS_DEBUG(sigar)) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fs_ping] %s -> %s: %s",
fs->dir_name, fs->dev_name,
((status == SIGAR_OK) ?
"OK" : sigar_rpc_strerror(status)));
}
*ptr = ':'; /* "hostname" -> "hostname:/mount" */
}
#endif
return status;
}
int sigar_cpu_info_list_create(sigar_cpu_info_list_t *cpu_infos)
{
cpu_infos->number = 0;
cpu_infos->size = SIGAR_CPU_INFO_MAX;
cpu_infos->data = malloc(sizeof(*(cpu_infos->data)) *
cpu_infos->size);
return SIGAR_OK;
}
int sigar_cpu_info_list_grow(sigar_cpu_info_list_t *cpu_infos)
{
cpu_infos->data = realloc(cpu_infos->data,
sizeof(*(cpu_infos->data)) *
(cpu_infos->size + SIGAR_CPU_INFO_MAX));
cpu_infos->size += SIGAR_CPU_INFO_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int)
sigar_cpu_info_list_destroy(sigar_t *sigar,
sigar_cpu_info_list_t *cpu_infos)
{
if (cpu_infos->size) {
free(cpu_infos->data);
cpu_infos->number = cpu_infos->size = 0;
}
return SIGAR_OK;
}
int sigar_cpu_list_create(sigar_cpu_list_t *cpulist)
{
cpulist->number = 0;
cpulist->size = SIGAR_CPU_INFO_MAX;
cpulist->data = malloc(sizeof(*(cpulist->data)) *
cpulist->size);
return SIGAR_OK;
}
int sigar_cpu_list_grow(sigar_cpu_list_t *cpulist)
{
cpulist->data = realloc(cpulist->data,
sizeof(*(cpulist->data)) *
(cpulist->size + SIGAR_CPU_INFO_MAX));
cpulist->size += SIGAR_CPU_INFO_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_cpu_list_destroy(sigar_t *sigar,
sigar_cpu_list_t *cpulist)
{
if (cpulist->size) {
free(cpulist->data);
cpulist->number = cpulist->size = 0;
}
return SIGAR_OK;
}
int sigar_net_route_list_create(sigar_net_route_list_t *routelist)
{
routelist->number = 0;
routelist->size = SIGAR_NET_ROUTE_LIST_MAX;
routelist->data = malloc(sizeof(*(routelist->data)) *
routelist->size);
return SIGAR_OK;
}
int sigar_net_route_list_grow(sigar_net_route_list_t *routelist)
{
routelist->data =
realloc(routelist->data,
sizeof(*(routelist->data)) *
(routelist->size + SIGAR_NET_ROUTE_LIST_MAX));
routelist->size += SIGAR_NET_ROUTE_LIST_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_net_route_list_destroy(sigar_t *sigar,
sigar_net_route_list_t *routelist)
{
if (routelist->size) {
free(routelist->data);
routelist->number = routelist->size = 0;
}
return SIGAR_OK;
}
int sigar_net_interface_list_create(sigar_net_interface_list_t *iflist)
{
iflist->number = 0;
iflist->size = SIGAR_NET_IFLIST_MAX;
iflist->data = malloc(sizeof(*(iflist->data)) *
iflist->size);
return SIGAR_OK;
}
int sigar_net_interface_list_grow(sigar_net_interface_list_t *iflist)
{
iflist->data = realloc(iflist->data,
sizeof(*(iflist->data)) *
(iflist->size + SIGAR_NET_IFLIST_MAX));
iflist->size += SIGAR_NET_IFLIST_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int)
sigar_net_interface_list_destroy(sigar_t *sigar,
sigar_net_interface_list_t *iflist)
{
unsigned int i;
if (iflist->size) {
for (i=0; i<iflist->number; i++) {
free(iflist->data[i]);
}
free(iflist->data);
iflist->number = iflist->size = 0;
}
return SIGAR_OK;
}
int sigar_net_connection_list_create(sigar_net_connection_list_t *connlist)
{
connlist->number = 0;
connlist->size = SIGAR_NET_CONNLIST_MAX;
connlist->data = malloc(sizeof(*(connlist->data)) *
connlist->size);
return SIGAR_OK;
}
int sigar_net_connection_list_grow(sigar_net_connection_list_t *connlist)
{
connlist->data =
realloc(connlist->data,
sizeof(*(connlist->data)) *
(connlist->size + SIGAR_NET_CONNLIST_MAX));
connlist->size += SIGAR_NET_CONNLIST_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int)
sigar_net_connection_list_destroy(sigar_t *sigar,
sigar_net_connection_list_t *connlist)
{
if (connlist->size) {
free(connlist->data);
connlist->number = connlist->size = 0;
}
return SIGAR_OK;
}
#if !defined(__linux__)
/*
* implement sigar_net_connection_list_get using sigar_net_connection_walk
* linux has its own list_get impl.
*/
static int net_connection_list_walker(sigar_net_connection_walker_t *walker,
sigar_net_connection_t *conn)
{
sigar_net_connection_list_t *connlist =
(sigar_net_connection_list_t *)walker->data;
SIGAR_NET_CONNLIST_GROW(connlist);
memcpy(&connlist->data[connlist->number++],
conn, sizeof(*conn));
return SIGAR_OK; /* continue loop */
}
SIGAR_DECLARE(int)
sigar_net_connection_list_get(sigar_t *sigar,
sigar_net_connection_list_t *connlist,
int flags)
{
int status;
sigar_net_connection_walker_t walker;
sigar_net_connection_list_create(connlist);
walker.sigar = sigar;
walker.flags = flags;
walker.data = connlist;
walker.add_connection = net_connection_list_walker;
status = sigar_net_connection_walk(&walker);
if (status != SIGAR_OK) {
sigar_net_connection_list_destroy(sigar, connlist);
}
return status;
}
#endif
static void sigar_net_listen_address_add(sigar_t *sigar,
sigar_net_connection_t *conn)
{
sigar_cache_entry_t *entry =
sigar_cache_get(sigar->net_listen, conn->local_port);
if (entry->value) {
if (conn->local_address.family == SIGAR_AF_INET6) {
return; /* prefer ipv4 */
}
}
else {
entry->value = malloc(sizeof(conn->local_address));
}
memcpy(entry->value, &conn->local_address,
sizeof(conn->local_address));
}
SIGAR_DECLARE(int)
sigar_net_listen_address_get(sigar_t *sigar,
unsigned long port,
sigar_net_address_t *address)
{
if (!sigar->net_listen ||
!sigar_cache_find(sigar->net_listen, port))
{
sigar_net_stat_t netstat;
int status =
sigar_net_stat_get(sigar, &netstat,
SIGAR_NETCONN_SERVER|SIGAR_NETCONN_TCP);
if (status != SIGAR_OK) {
return status;
}
}
if (sigar_cache_find(sigar->net_listen, port)) {
void *value = sigar_cache_get(sigar->net_listen, port)->value;
memcpy(address, value, sizeof(*address));
return SIGAR_OK;
}
else {
return ENOENT;
}
}
typedef struct {
sigar_net_stat_t *netstat;
sigar_net_connection_list_t *connlist;
} net_stat_getter_t;
static int net_stat_walker(sigar_net_connection_walker_t *walker,
sigar_net_connection_t *conn)
{
int state = conn->state;
sigar_cache_t *listen_ports = walker->sigar->net_listen;
net_stat_getter_t *getter =
(net_stat_getter_t *)walker->data;
if (conn->type == SIGAR_NETCONN_TCP) {
getter->netstat->tcp_states[state]++;
/* XXX listen_ports may get stale */
if (state == SIGAR_TCP_LISTEN) {
sigar_net_listen_address_add(walker->sigar, conn);
}
else {
if (sigar_cache_find(listen_ports,
conn->local_port))
{
getter->netstat->tcp_inbound_total++;
}
else {
getter->netstat->tcp_outbound_total++;
}
}
}
else if (conn->type == SIGAR_NETCONN_UDP) {
/*XXX*/
}
getter->netstat->all_inbound_total =
getter->netstat->tcp_inbound_total;
getter->netstat->all_outbound_total =
getter->netstat->tcp_outbound_total;
return SIGAR_OK;
}
SIGAR_DECLARE(int)
sigar_net_stat_get(sigar_t *sigar,
sigar_net_stat_t *netstat,
int flags)
{
sigar_net_connection_walker_t walker;
net_stat_getter_t getter;
if (!sigar->net_listen) {
sigar->net_listen = sigar_cache_new(32);
}
SIGAR_ZERO(netstat);
getter.netstat = netstat;
walker.sigar = sigar;
walker.data = &getter;
walker.add_connection = net_stat_walker;
walker.flags = flags;
return sigar_net_connection_walk(&walker);
}
typedef struct {
sigar_net_stat_t *netstat;
sigar_net_address_t *address;
unsigned long port;
} net_stat_port_getter_t;
static int net_stat_port_walker(sigar_net_connection_walker_t *walker,
sigar_net_connection_t *conn)
{
net_stat_port_getter_t *getter =
(net_stat_port_getter_t *)walker->data;
sigar_net_stat_t *netstat = getter->netstat;
if (conn->type == SIGAR_NETCONN_TCP) {
if (conn->local_port == getter->port) {
netstat->all_inbound_total++;
if (sigar_net_address_equals(getter->address,
&conn->local_address) == SIGAR_OK)
{
netstat->tcp_inbound_total++;
}
}
else if (conn->remote_port == getter->port) {
netstat->all_outbound_total++;
if (sigar_net_address_equals(getter->address,
&conn->remote_address) == SIGAR_OK)
{
netstat->tcp_outbound_total++;
}
}
else {
return SIGAR_OK;
}
netstat->tcp_states[conn->state]++;
}
else if (conn->type == SIGAR_NETCONN_UDP) {
/*XXX*/
}
return SIGAR_OK;
}
SIGAR_DECLARE(int)
sigar_net_stat_port_get(sigar_t *sigar,
sigar_net_stat_t *netstat,
int flags,
sigar_net_address_t *address,
unsigned long port)
{
sigar_net_connection_walker_t walker;
net_stat_port_getter_t getter;
SIGAR_ZERO(netstat);
getter.netstat = netstat;
getter.address = address;
getter.port = port;
walker.sigar = sigar;
walker.data = &getter;
walker.add_connection = net_stat_port_walker;
walker.flags = flags;
if (SIGAR_LOG_IS_DEBUG(sigar)) {
char name[SIGAR_FQDN_LEN];
sigar_net_address_to_string(sigar, address, name);
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[net_stat_port] using address '%s:%d'",
name, port);
}
return sigar_net_connection_walk(&walker);
}
static int tcp_curr_estab_count(sigar_net_connection_walker_t *walker,
sigar_net_connection_t *conn)
{
if ((conn->state == SIGAR_TCP_ESTABLISHED) ||
(conn->state == SIGAR_TCP_CLOSE_WAIT))
{
((sigar_tcp_t *)walker->data)->curr_estab++;
}
return SIGAR_OK;
}
/* TCP-MIB::tcpCurrEstab */
int sigar_tcp_curr_estab(sigar_t *sigar, sigar_tcp_t *tcp)
{
sigar_net_connection_walker_t walker;
walker.sigar = sigar;
walker.data = tcp;
walker.add_connection = tcp_curr_estab_count;
walker.flags = SIGAR_NETCONN_CLIENT|SIGAR_NETCONN_TCP;
tcp->curr_estab = 0;
return sigar_net_connection_walk(&walker);
}
int sigar_arp_list_create(sigar_arp_list_t *arplist)
{
arplist->number = 0;
arplist->size = SIGAR_ARP_LIST_MAX;
arplist->data = malloc(sizeof(*(arplist->data)) *
arplist->size);
return SIGAR_OK;
}
int sigar_arp_list_grow(sigar_arp_list_t *arplist)
{
arplist->data = realloc(arplist->data,
sizeof(*(arplist->data)) *
(arplist->size + SIGAR_ARP_LIST_MAX));
arplist->size += SIGAR_ARP_LIST_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_arp_list_destroy(sigar_t *sigar,
sigar_arp_list_t *arplist)
{
if (arplist->size) {
free(arplist->data);
arplist->number = arplist->size = 0;
}
return SIGAR_OK;
}
int sigar_who_list_create(sigar_who_list_t *wholist)
{
wholist->number = 0;
wholist->size = SIGAR_WHO_LIST_MAX;
wholist->data = malloc(sizeof(*(wholist->data)) *
wholist->size);
return SIGAR_OK;
}
int sigar_who_list_grow(sigar_who_list_t *wholist)
{
wholist->data = realloc(wholist->data,
sizeof(*(wholist->data)) *
(wholist->size + SIGAR_WHO_LIST_MAX));
wholist->size += SIGAR_WHO_LIST_MAX;
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_who_list_destroy(sigar_t *sigar,
sigar_who_list_t *wholist)
{
if (wholist->size) {
free(wholist->data);
wholist->number = wholist->size = 0;
}
return SIGAR_OK;
}
#if defined(NETWARE)
static char *getpass(const char *prompt)
{
static char password[BUFSIZ];
fputs(prompt, stderr);
fgets((char *)&password, sizeof(password), stdin);
return (char *)&password;
}
#endif
#define WHOCPY(dest, src) \
SIGAR_SSTRCPY(dest, src); \
if (sizeof(src) < sizeof(dest)) \
dest[sizeof(src)] = '\0'
static int sigar_who_utmp(sigar_t *sigar,
sigar_who_list_t *wholist)
{
#if defined(HAVE_UTMPX_H)
struct utmpx *ut;
setutxent();
while ((ut = getutxent()) != NULL) {
sigar_who_t *who;
if (*ut->ut_user == '\0') {
continue;
}
if (ut->ut_type != USER_PROCESS) {
continue;
}
SIGAR_WHO_LIST_GROW(wholist);
who = &wholist->data[wholist->number++];
WHOCPY(who->user, ut->ut_user);
WHOCPY(who->device, ut->ut_line);
WHOCPY(who->host, ut->ut_host);
who->time = ut->ut_tv.tv_sec;
}
endutxent();
#elif defined(HAVE_UTMP_H)
FILE *fp;
struct utmp ut;
if (!(fp = fopen(_PATH_UTMP, "r"))) {
return errno;
}
while (fread(&ut, sizeof(ut), 1, fp) == 1) {
sigar_who_t *who;
if (*ut.ut_name == '\0') {
continue;
}
#ifdef USER_PROCESS
if (ut.ut_type != USER_PROCESS) {
continue;
}
#endif
SIGAR_WHO_LIST_GROW(wholist);
who = &wholist->data[wholist->number++];
WHOCPY(who->user, ut.ut_name);
WHOCPY(who->device, ut.ut_line);
WHOCPY(who->host, ut.ut_host);
who->time = ut.ut_time;
}
fclose(fp);
#endif
return SIGAR_OK;
}
#if defined(WIN32)
int sigar_who_list_get_win32(sigar_t *sigar,
sigar_who_list_t *wholist);
SIGAR_DECLARE(int) sigar_who_list_get(sigar_t *sigar,
sigar_who_list_t *wholist)
{
sigar_who_list_create(wholist);
/* cygwin ssh */
sigar_who_utmp(sigar, wholist);
sigar_who_list_get_win32(sigar, wholist);
return SIGAR_OK;
}
SIGAR_DECLARE(int) sigar_resource_limit_get(sigar_t *sigar,
sigar_resource_limit_t *rlimit)
{
MEMORY_BASIC_INFORMATION meminfo;
memset(rlimit, 0x7fffffff, sizeof(*rlimit));
if (VirtualQuery((LPCVOID)&meminfo, &meminfo, sizeof(meminfo))) {
rlimit->stack_cur =
(DWORD)&meminfo - (DWORD)meminfo.AllocationBase;
rlimit->stack_max =
((DWORD)meminfo.BaseAddress + meminfo.RegionSize) -
(DWORD)meminfo.AllocationBase;
}
rlimit->virtual_memory_max = rlimit->virtual_memory_cur =
0x80000000UL;
return SIGAR_OK;
}
#elif defined(NETWARE)
int sigar_resource_limit_get(sigar_t *sigar,
sigar_resource_limit_t *rlimit)
{
return SIGAR_ENOTIMPL;
}
int sigar_who_list_get(sigar_t *sigar,
sigar_who_list_t *wholist)
{
return SIGAR_ENOTIMPL;
}
#else
#ifndef _AIX
int sigar_who_list_get(sigar_t *sigar,
sigar_who_list_t *wholist)
{
int status;
sigar_who_list_create(wholist);
status = sigar_who_utmp(sigar, wholist);
if (status != SIGAR_OK) {
sigar_who_list_destroy(sigar, wholist);
return status;
}
return SIGAR_OK;
}
#endif
static int sigar_get_default_gateway(sigar_t *sigar,
sigar_net_info_t *netinfo)
{
int status, i;
sigar_net_route_list_t routelist;
status = sigar_net_route_list_get(sigar, &routelist);
if (status != SIGAR_OK) {
return status;
}
for (i=0; i<routelist.number; i++) {
if ((routelist.data[i].flags & SIGAR_RTF_GATEWAY) &&
(routelist.data[i].destination.addr.in == 0))
{
sigar_net_address_to_string(sigar,
&routelist.data[i].gateway,
netinfo->default_gateway);
SIGAR_STRNCPY(netinfo->default_gateway_interface,
routelist.data[i].ifname,
sizeof(netinfo->default_gateway_interface));
break;
}
}
sigar_net_route_list_destroy(sigar, &routelist);
return SIGAR_OK;
}
int sigar_net_info_get(sigar_t *sigar,
sigar_net_info_t *netinfo)
{
int size;
char buffer[BUFSIZ], *ptr;
FILE *fp;
SIGAR_ZERO(netinfo);
if ((fp = fopen("/etc/resolv.conf", "r"))) {
while ((ptr = fgets(buffer, sizeof(buffer), fp))) {
int len;
SIGAR_SKIP_SPACE(ptr);
if ((*ptr == '#') ||
!(ptr = strstr(ptr, "nameserver")))
{
continue;
}
ptr += 10;
SIGAR_SKIP_SPACE(ptr);
len = strlen(ptr);
ptr[len-1] = '\0'; /* chop \n */
if (!netinfo->primary_dns[0]) {
SIGAR_SSTRCPY(netinfo->primary_dns, ptr);
}
else if (!netinfo->secondary_dns[0]) {
SIGAR_SSTRCPY(netinfo->secondary_dns, ptr);
}
else {
break;
}
}
fclose(fp);
} /* else /etc/resolv.conf may not exist if unplugged (MacOSX) */
size = sizeof(netinfo->host_name)-1;
if (gethostname(netinfo->host_name, size) == 0) {
netinfo->host_name[size] = '\0';
}
else {
netinfo->host_name[0] = '\0';
}
size = sizeof(netinfo->domain_name)-1;
if (getdomainname(netinfo->domain_name, size) == 0) {
netinfo->domain_name[size] = '\0';
}
else {
netinfo->domain_name[0] = '\0';
}
sigar_get_default_gateway(sigar, netinfo);
return SIGAR_OK;
}
#include <sys/resource.h>
#define OffsetOf(structure, field) \
(size_t)(&((structure *)NULL)->field)
#define RlimitOffsets(field) \
OffsetOf(sigar_resource_limit_t, field##_cur), \
OffsetOf(sigar_resource_limit_t, field##_max)
#define RlimitSet(structure, ptr, val) \
*(sigar_uint64_t *)((char *)structure + (int)(long)ptr) = val
typedef struct {
int resource;
int factor;
size_t cur;
size_t max;
} rlimit_field_t;
#ifndef RLIMIT_RSS
#define RLIMIT_RSS (RLIM_NLIMITS+1)
#endif
#ifndef RLIMIT_NPROC
#define RLIMIT_NPROC (RLIM_NLIMITS+2)
#endif
#define RLIMIT_PSIZE (RLIM_NLIMITS+3)
#ifndef RLIMIT_AS
# if defined(RLIMIT_VMEM)
# define RLIMIT_AS RLIMIT_VMEM
# elif defined(RLIMIT_RSS)
# define RLIMIT_AS RLIMIT_RSS
# endif
#endif
static rlimit_field_t sigar_rlimits[] = {
{ RLIMIT_CPU, 1, RlimitOffsets(cpu) },
{ RLIMIT_FSIZE, 1024, RlimitOffsets(file_size) },
{ RLIMIT_DATA, 1024, RlimitOffsets(data) },
{ RLIMIT_STACK, 1024, RlimitOffsets(stack) },
{ RLIMIT_PSIZE, 512, RlimitOffsets(pipe_size) },
{ RLIMIT_CORE, 1024, RlimitOffsets(core) },
{ RLIMIT_RSS, 1024, RlimitOffsets(memory) },
{ RLIMIT_NPROC, 1, RlimitOffsets(processes) },
{ RLIMIT_NOFILE, 1, RlimitOffsets(open_files) },
{ RLIMIT_AS, 1024, RlimitOffsets(virtual_memory) },
{ -1 }
};
#define RlimitScale(val) \
if (val != RLIM_INFINITY) val /= r->factor
#define RlimitHS(val) \
rl.rlim_cur = rl.rlim_max = (val)
int sigar_resource_limit_get(sigar_t *sigar,
sigar_resource_limit_t *rlimit)
{
int i;
for (i=0; sigar_rlimits[i].resource != -1; i++) {
struct rlimit rl;
rlimit_field_t *r = &sigar_rlimits[i];
if (r->resource > RLIM_NLIMITS) {
switch (r->resource) {
case RLIMIT_NPROC:
RlimitHS(sysconf(_SC_CHILD_MAX));
break;
case RLIMIT_PSIZE:
RlimitHS(PIPE_BUF/512);
break;
default:
RlimitHS(RLIM_INFINITY);
break;
}
}
else if (getrlimit(r->resource, &rl) != 0) {
RlimitHS(RLIM_INFINITY);
}
else {
RlimitScale(rl.rlim_cur);
RlimitScale(rl.rlim_max);
}
RlimitSet(rlimit, r->cur, rl.rlim_cur);
RlimitSet(rlimit, r->max, rl.rlim_max);
}
return SIGAR_OK;
}
#endif
#if !defined(WIN32) && !defined(NETWARE) && !defined(DARWIN) && \
!defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
/* XXX: prolly will be moving these stuffs into os_net.c */
#include <sys/ioctl.h>
#include <net/if.h>
#ifndef SIOCGIFCONF
#include <sys/sockio.h>
#endif
#if defined(_AIX) || defined(__osf__) /* good buddies */
#include <net/if_dl.h>
static void hwaddr_aix_lookup(sigar_t *sigar, sigar_net_interface_config_t *ifconfig)
{
char *ent, *end;
struct ifreq *ifr;
/* XXX: assumes sigar_net_interface_list_get has been called */
end = sigar->ifconf_buf + sigar->ifconf_len;
for (ent = sigar->ifconf_buf;
ent < end;
ent += sizeof(*ifr))
{
ifr = (struct ifreq *)ent;
if (ifr->ifr_addr.sa_family != AF_LINK) {
continue;
}
if (strEQ(ifr->ifr_name, ifconfig->name)) {
struct sockaddr_dl *sdl = (struct sockaddr_dl *)&ifr->ifr_addr;
sigar_net_address_mac_set(ifconfig->hwaddr,
LLADDR(sdl),
sdl->sdl_alen);
return;
}
}
sigar_hwaddr_set_null(ifconfig);
}
#elif !defined(SIOCGIFHWADDR)
#include <net/if_arp.h>
static void hwaddr_arp_lookup(sigar_net_interface_config_t *ifconfig, int sock)
{
struct arpreq areq;
struct sockaddr_in *sa;
memset(&areq, 0, sizeof(areq));
sa = (struct sockaddr_in *)&areq.arp_pa;
sa->sin_family = AF_INET;
sa->sin_addr.s_addr = ifconfig->address.addr.in;
if (ioctl(sock, SIOCGARP, &areq) < 0) {
/* ho-hum */
sigar_hwaddr_set_null(ifconfig);
}
else {
sigar_net_address_mac_set(ifconfig->hwaddr,
areq.arp_ha.sa_data,
SIGAR_IFHWADDRLEN);
}
}
#endif
#ifdef __linux__
#include <net/if_arp.h>
#ifndef ARPHRD_CISCO /* not in 2.2 kernel headers */
#define ARPHRD_CISCO 513 /* Cisco HDLC. */
#endif
static void get_interface_type(sigar_net_interface_config_t *ifconfig,
int family)
{
char *type;
switch (family) {
case ARPHRD_SLIP:
type = SIGAR_NIC_SLIP;
break;
case ARPHRD_CSLIP:
type = SIGAR_NIC_CSLIP;
break;
case ARPHRD_SLIP6:
type = SIGAR_NIC_SLIP6;
break;
case ARPHRD_CSLIP6:
type = SIGAR_NIC_CSLIP6;
break;
case ARPHRD_ADAPT:
type = SIGAR_NIC_ADAPTIVE;
break;
case ARPHRD_ETHER:
type = SIGAR_NIC_ETHERNET;
break;
case ARPHRD_ASH:
type = SIGAR_NIC_ASH;
break;
case ARPHRD_FDDI:
type = SIGAR_NIC_FDDI;
break;
case ARPHRD_HIPPI:
type = SIGAR_NIC_HIPPI;
break;
case ARPHRD_AX25:
type = SIGAR_NIC_AX25;
break;
case ARPHRD_ROSE:
type = SIGAR_NIC_ROSE;
break;
case ARPHRD_NETROM:
type = SIGAR_NIC_NETROM;
break;
case ARPHRD_X25:
type = SIGAR_NIC_X25;
break;
case ARPHRD_TUNNEL:
type = SIGAR_NIC_TUNNEL;
break;
case ARPHRD_PPP:
type = SIGAR_NIC_PPP;
break;
case ARPHRD_CISCO:
type = SIGAR_NIC_HDLC;
break;
case ARPHRD_LAPB:
type = SIGAR_NIC_LAPB;
break;
case ARPHRD_ARCNET:
type = SIGAR_NIC_ARCNET;
break;
case ARPHRD_DLCI:
type = SIGAR_NIC_DLCI;
break;
case ARPHRD_FRAD:
type = SIGAR_NIC_FRAD;
break;
case ARPHRD_SIT:
type = SIGAR_NIC_SIT;
break;
case ARPHRD_IRDA:
type = SIGAR_NIC_IRDA;
break;
case ARPHRD_ECONET:
type = SIGAR_NIC_EC;
break;
default:
type = SIGAR_NIC_UNSPEC;
break;
}
SIGAR_SSTRCPY(ifconfig->type, type);
}
#endif
int sigar_net_interface_config_get(sigar_t *sigar, const char *name,
sigar_net_interface_config_t *ifconfig)
{
int sock;
struct ifreq ifr;
if (!name) {
return sigar_net_interface_config_primary_get(sigar, ifconfig);
}
SIGAR_ZERO(ifconfig);
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
return errno;
}
SIGAR_SSTRCPY(ifconfig->name, name);
SIGAR_SSTRCPY(ifr.ifr_name, name);
#define ifr_s_addr(ifr) \
((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr
if (!ioctl(sock, SIOCGIFADDR, &ifr)) {
sigar_net_address_set(ifconfig->address,
ifr_s_addr(ifr));
}
if (!ioctl(sock, SIOCGIFNETMASK, &ifr)) {
sigar_net_address_set(ifconfig->netmask,
ifr_s_addr(ifr));
}
if (!ioctl(sock, SIOCGIFFLAGS, &ifr)) {
sigar_uint64_t flags = ifr.ifr_flags;
#ifdef __linux__
# ifndef IFF_DYNAMIC
# define IFF_DYNAMIC 0x8000 /* not in 2.2 kernel */
# endif /* IFF_DYNAMIC */
int is_mcast = flags & IFF_MULTICAST;
int is_slave = flags & IFF_SLAVE;
int is_master = flags & IFF_MASTER;
int is_dynamic = flags & IFF_DYNAMIC;
/*
* XXX: should just define SIGAR_IFF_*
* and test IFF_* bits on given platform.
* this is the only diff between solaris/hpux/linux
* for the flags we care about.
*
*/
flags &= ~(IFF_MULTICAST|IFF_SLAVE|IFF_MASTER);
if (is_mcast) {
flags |= SIGAR_IFF_MULTICAST;
}
if (is_slave) {
flags |= SIGAR_IFF_SLAVE;
}
if (is_master) {
flags |= SIGAR_IFF_MASTER;
}
if (is_dynamic) {
flags |= SIGAR_IFF_DYNAMIC;
}
#endif
ifconfig->flags = flags;
}
else {
/* should always be able to get flags for existing device */
/* other ioctls may fail if device is not enabled: ok */
close(sock);
return errno;
}
if (ifconfig->flags & IFF_LOOPBACK) {
sigar_net_address_set(ifconfig->destination,
ifconfig->address.addr.in);
sigar_net_address_set(ifconfig->broadcast, 0);
sigar_hwaddr_set_null(ifconfig);
SIGAR_SSTRCPY(ifconfig->type,
SIGAR_NIC_LOOPBACK);
}
else {
if (!ioctl(sock, SIOCGIFDSTADDR, &ifr)) {
sigar_net_address_set(ifconfig->destination,
ifr_s_addr(ifr));
}
if (!ioctl(sock, SIOCGIFBRDADDR, &ifr)) {
sigar_net_address_set(ifconfig->broadcast,
ifr_s_addr(ifr));
}
#if defined(SIOCGIFHWADDR)
if (!ioctl(sock, SIOCGIFHWADDR, &ifr)) {
get_interface_type(ifconfig,
ifr.ifr_hwaddr.sa_family);
sigar_net_address_mac_set(ifconfig->hwaddr,
ifr.ifr_hwaddr.sa_data,
IFHWADDRLEN);
}
#elif defined(_AIX) || defined(__osf__)
hwaddr_aix_lookup(sigar, ifconfig);
SIGAR_SSTRCPY(ifconfig->type,
SIGAR_NIC_ETHERNET);
#else
hwaddr_arp_lookup(ifconfig, sock);
SIGAR_SSTRCPY(ifconfig->type,
SIGAR_NIC_ETHERNET);
#endif
}
#if defined(SIOCGLIFMTU) && !defined(__hpux)
{
struct lifreq lifr;
SIGAR_SSTRCPY(lifr.lifr_name, name);
if(!ioctl(sock, SIOCGLIFMTU, &lifr)) {
ifconfig->mtu = lifr.lifr_mtu;
}
}
#elif defined(SIOCGIFMTU)
if (!ioctl(sock, SIOCGIFMTU, &ifr)) {
# if defined(__hpux)
ifconfig->mtu = ifr.ifr_metric;
# else
ifconfig->mtu = ifr.ifr_mtu;
#endif
}
#else
ifconfig->mtu = 0; /*XXX*/
#endif
if (!ioctl(sock, SIOCGIFMETRIC, &ifr)) {
ifconfig->metric = ifr.ifr_metric ? ifr.ifr_metric : 1;
}
#if defined(SIOCGIFTXQLEN)
if (!ioctl(sock, SIOCGIFTXQLEN, &ifr)) {
ifconfig->tx_queue_len = ifr.ifr_qlen;
}
else {
ifconfig->tx_queue_len = -1; /* net-tools behaviour */
}
#else
ifconfig->tx_queue_len = -1;
#endif
close(sock);
/* XXX can we get a better description like win32? */
SIGAR_SSTRCPY(ifconfig->description,
ifconfig->name);
sigar_net_interface_ipv6_config_init(ifconfig);
sigar_net_interface_ipv6_config_get(sigar, name, ifconfig);
return SIGAR_OK;
}
#ifdef _AIX
# define MY_SIOCGIFCONF CSIOCGIFCONF
#else
# define MY_SIOCGIFCONF SIOCGIFCONF
#endif
#ifdef __osf__
static int sigar_netif_configured(sigar_t *sigar, char *name)
{
int status;
sigar_net_interface_config_t ifconfig;
status = sigar_net_interface_config_get(sigar, name, &ifconfig);
return status == SIGAR_OK;
}
#endif
#ifdef __linux__
static SIGAR_INLINE int has_interface(sigar_net_interface_list_t *iflist,
char *name)
{
register int i;
register int num = iflist->number;
register char **data = iflist->data;
for (i=0; i<num; i++) {
if (strEQ(name, data[i])) {
return 1;
}
}
return 0;
}
static int proc_net_interface_list_get(sigar_t *sigar,
sigar_net_interface_list_t *iflist)
{
/* certain interfaces such as VMware vmnic
* are not returned by ioctl(SIOCGIFCONF).
* check /proc/net/dev for any ioctl missed.
*/
char buffer[BUFSIZ];
FILE *fp = fopen("/proc/net/dev", "r");
if (!fp) {
return errno;
}
/* skip header */
fgets(buffer, sizeof(buffer), fp);
fgets(buffer, sizeof(buffer), fp);
while (fgets(buffer, sizeof(buffer), fp)) {
char *ptr, *dev;
dev = buffer;
while (isspace(*dev)) {
dev++;
}
if (!(ptr = strchr(dev, ':'))) {
continue;
}
*ptr++ = 0;
if (has_interface(iflist, dev)) {
continue;
}
SIGAR_NET_IFLIST_GROW(iflist);
iflist->data[iflist->number++] =
sigar_strdup(dev);
}
fclose(fp);
return SIGAR_OK;
}
#endif
int sigar_net_interface_list_get(sigar_t *sigar,
sigar_net_interface_list_t *iflist)
{
int n, lastlen=0;
struct ifreq *ifr;
struct ifconf ifc;
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
return errno;
}
for (;;) {
if (!sigar->ifconf_buf || lastlen) {
sigar->ifconf_len += sizeof(struct ifreq) * SIGAR_NET_IFLIST_MAX;
sigar->ifconf_buf = realloc(sigar->ifconf_buf, sigar->ifconf_len);
}
ifc.ifc_len = sigar->ifconf_len;
ifc.ifc_buf = sigar->ifconf_buf;
if (ioctl(sock, MY_SIOCGIFCONF, &ifc) < 0) {
/* EINVAL should mean num_interfaces > ifc.ifc_len */
if ((errno != EINVAL) ||
(lastlen == ifc.ifc_len))
{
free(ifc.ifc_buf);
return errno;
}
}
if (ifc.ifc_len < sigar->ifconf_len) {
break; /* got em all */
}
if (ifc.ifc_len != lastlen) {
/* might be more */
lastlen = ifc.ifc_len;
continue;
}
break;
}
close(sock);
iflist->number = 0;
iflist->size = ifc.ifc_len;
iflist->data = malloc(sizeof(*(iflist->data)) *
iflist->size);
ifr = ifc.ifc_req;
for (n = 0; n < ifc.ifc_len; n += sizeof(struct ifreq), ifr++) {
#if defined(_AIX) || defined(__osf__) /* pass the bourbon */
if (ifr->ifr_addr.sa_family != AF_LINK) {
/* XXX: dunno if this is right.
* otherwise end up with two 'en0' and three 'lo0'
* with the same ip address.
*/
continue;
}
# ifdef __osf__
/* weed out "sl0", "tun0" and the like */
/* XXX must be a better way to check this */
if (!sigar_netif_configured(sigar, ifr->ifr_name)) {
continue;
}
# endif
#endif
iflist->data[iflist->number++] =
sigar_strdup(ifr->ifr_name);
}
#ifdef __linux__
proc_net_interface_list_get(sigar, iflist);
#endif
return SIGAR_OK;
}
#endif /* WIN32 */
SIGAR_DECLARE(int)
sigar_net_interface_config_primary_get(sigar_t *sigar,
sigar_net_interface_config_t *ifconfig)
{
int i, status, found=0;
sigar_net_interface_list_t iflist;
sigar_net_interface_config_t possible_config;
possible_config.flags = 0;
if ((status = sigar_net_interface_list_get(sigar, &iflist)) != SIGAR_OK) {
return status;
}
for (i=0; i<iflist.number; i++) {
status = sigar_net_interface_config_get(sigar,
iflist.data[i], ifconfig);
if ((status != SIGAR_OK) ||
(ifconfig->flags & SIGAR_IFF_LOOPBACK) ||
!ifconfig->hwaddr.addr.in) /* no mac address */
{
continue;
}
if (!possible_config.flags) {
/* save for later for use if we're not connected to the net
* or all interfaces are aliases (e.g. solaris zone)
*/
memcpy(&possible_config, ifconfig, sizeof(*ifconfig));
}
if (!ifconfig->address.addr.in) {
continue; /* no ip address */
}
if (strchr(iflist.data[i], ':')) {
continue; /* alias */
}
found = 1;
break;
}
sigar_net_interface_list_destroy(sigar, &iflist);
if (found) {
return SIGAR_OK;
}
else if (possible_config.flags) {
memcpy(ifconfig, &possible_config, sizeof(*ifconfig));
return SIGAR_OK;
}
else {
return SIGAR_ENXIO;
}
}
static int fqdn_ip_get(sigar_t *sigar, char *name)
{
sigar_net_interface_config_t ifconfig;
int status;
status = sigar_net_interface_config_primary_get(sigar, &ifconfig);
if (status != SIGAR_OK) {
return status;
}
if (!ifconfig.address.addr.in) {
return SIGAR_ENXIO;
}
sigar_net_address_to_string(sigar, &ifconfig.address, name);
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] using ip address '%s' for fqdn",
name);
return SIGAR_OK;
}
struct hostent *sigar_gethostbyname(const char *name,
sigar_hostent_t *data)
{
struct hostent *hp = NULL;
#if defined(__linux__)
gethostbyname_r(name, &data->hs,
data->buffer, sizeof(data->buffer),
&hp, &data->error);
#elif defined(__sun)
hp = gethostbyname_r(name, &data->hs,
data->buffer, sizeof(data->buffer),
&data->error);
#elif defined(SIGAR_HAS_HOSTENT_DATA)
if (gethostbyname_r(name, &data->hs, &data->hd) == 0) {
hp = &data->hs;
}
else {
data->error = h_errno;
}
#else
hp = gethostbyname(name);
#endif
return hp;
}
static struct hostent *sigar_gethostbyaddr(const char *addr,
int len, int type,
sigar_hostent_t *data)
{
struct hostent *hp = NULL;
#if defined(__linux__)
gethostbyaddr_r(addr, len, type,
&data->hs,
data->buffer, sizeof(data->buffer),
&hp, &data->error);
#elif defined(__sun)
hp = gethostbyaddr_r(addr, len, type,
&data->hs,
data->buffer, sizeof(data->buffer),
&data->error);
#elif defined(SIGAR_HAS_HOSTENT_DATA)
if (gethostbyaddr_r((char *)addr, len, type,
&data->hs, &data->hd) == 0)
{
hp = &data->hs;
}
else {
data->error = h_errno;
}
#else
if (!(hp = gethostbyaddr(addr, len, type))) {
data->error = h_errno;
}
#endif
return hp;
}
#define IS_FQDN(name) \
(name && strchr(name, '.'))
#define IS_FQDN_MATCH(lookup, name) \
(IS_FQDN(lookup) && strnEQ(lookup, name, strlen(name)))
#define FQDN_SET(fqdn) \
SIGAR_STRNCPY(name, fqdn, namelen)
SIGAR_DECLARE(int) sigar_fqdn_get(sigar_t *sigar, char *name, int namelen)
{
register int is_debug = SIGAR_LOG_IS_DEBUG(sigar);
sigar_hostent_t data;
struct hostent *p;
char domain[SIGAR_FQDN_LEN + 1];
#ifdef WIN32
int status = sigar_wsa_init(sigar);
if (status != SIGAR_OK) {
return status;
}
#endif
if (gethostname(name, namelen - 1) != 0) {
sigar_log_printf(sigar, SIGAR_LOG_ERROR,
"[fqdn] gethostname failed: %s",
sigar_strerror(sigar, errno));
return errno;
}
else {
if (is_debug) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] gethostname()=='%s'",
name);
}
}
if (!(p = sigar_gethostbyname(name, &data))) {
if (is_debug) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] gethostbyname(%s) failed: %s",
name, sigar_strerror(sigar, errno));
}
if (!IS_FQDN(name)) {
fqdn_ip_get(sigar, name);
}
return SIGAR_OK;
}
if (IS_FQDN_MATCH(p->h_name, name)) {
FQDN_SET(p->h_name);
sigar_log(sigar, SIGAR_LOG_DEBUG,
"[fqdn] resolved using gethostbyname.h_name");
return SIGAR_OK;
}
else {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] unresolved using gethostbyname.h_name");
}
if (p->h_aliases) {
int i;
for (i=0; p->h_aliases[i]; i++) {
if (IS_FQDN_MATCH(p->h_aliases[i], name)) {
FQDN_SET(p->h_aliases[i]);
sigar_log(sigar, SIGAR_LOG_DEBUG,
"[fqdn] resolved using gethostbyname.h_aliases");
return SIGAR_OK;
}
else if (is_debug) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] gethostbyname(%s).alias[%d]=='%s'",
name, i, p->h_aliases[i]);
}
}
}
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] unresolved using gethostbyname.h_aliases");
if (p->h_addr_list) {
int i,j;
for (i=0; p->h_addr_list[i]; i++) {
char addr[SIGAR_INET6_ADDRSTRLEN];
struct in_addr *in =
(struct in_addr *)p->h_addr_list[i];
struct hostent *q =
sigar_gethostbyaddr(p->h_addr_list[i],
p->h_length,
p->h_addrtype,
&data);
if (is_debug) {
sigar_inet_ntoa(sigar, in->s_addr, addr);
}
if (!q) {
if (is_debug) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] gethostbyaddr(%s) failed: %s",
addr,
sigar_strerror(sigar, errno));
}
continue;
}
if (IS_FQDN_MATCH(q->h_name, name)) {
FQDN_SET(q->h_name);
sigar_log(sigar, SIGAR_LOG_DEBUG,
"[fqdn] resolved using gethostbyaddr.h_name");
return SIGAR_OK;
}
else {
if (is_debug) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] gethostbyaddr(%s)=='%s'",
addr, q->h_name);
}
for (j=0; q->h_aliases[j]; j++) {
if (IS_FQDN_MATCH(q->h_aliases[j], name)) {
FQDN_SET(q->h_aliases[j]);
sigar_log(sigar, SIGAR_LOG_DEBUG,
"[fqdn] resolved using "
"gethostbyaddr.h_aliases");
return SIGAR_OK;
}
else if (is_debug) {
sigar_log_printf(sigar, SIGAR_LOG_DEBUG,
"[fqdn] gethostbyaddr(%s).alias[%d]=='%s'",
addr, j, q->h_aliases[j]);
}
}
}
}
}
sigar_log(sigar, SIGAR_LOG_DEBUG,
"[fqdn] unresolved using gethostbyname.h_addr_list");
#if !defined(WIN32) && !defined(NETWARE)
if (!IS_FQDN(name) && /* e.g. aix gethostname is already fqdn */
(getdomainname(domain, sizeof(domain) - 1) == 0) &&
(domain[0] != '\0') &&
(domain[0] != '(')) /* linux default is "(none)" */
{
/* sprintf(name, "%s.%s", name, domain); */
char *ptr = name;
int len = strlen(name);
ptr += len;
*ptr++ = '.';
namelen -= (len+1);
SIGAR_STRNCPY(ptr, domain, namelen);
sigar_log(sigar, SIGAR_LOG_DEBUG,
"[fqdn] resolved using getdomainname");
}
else {
sigar_log(sigar, SIGAR_LOG_DEBUG,
"[fqdn] getdomainname failed");
}
#endif
if (!IS_FQDN(name)) {
fqdn_ip_get(sigar, name);
}
return SIGAR_OK;
}
#ifndef MAX_STRING_LEN
#define MAX_STRING_LEN 8192
#endif
#ifdef WIN32
/* The windows version of getPasswordNative was lifted from apr */
SIGAR_DECLARE(char *) sigar_password_get(const char *prompt)
{
static char password[MAX_STRING_LEN];
int n = 0;
int ch;
fputs(prompt, stderr);
fflush(stderr);
while ((ch = _getch()) != '\r') {
if (ch == EOF) /* EOF */ {
return NULL;
}
else if (ch == 0 || ch == 0xE0) {
/* FN Keys (0 or E0) are a sentinal for a FN code */
ch = (ch << 4) | _getch();
/* Catch {DELETE}, {<--}, Num{DEL} and Num{<--} */
if ((ch == 0xE53 || ch == 0xE4B || ch == 0x053 || ch == 0x04b) && n) {
password[--n] = '\0';
fputs("\b \b", stderr);
fflush(stderr);
}
else {
fputc('\a', stderr);
fflush(stderr);
}
}
else if ((ch == '\b' || ch == 127) && n) /* BS/DEL */ {
password[--n] = '\0';
fputs("\b \b", stderr);
fflush(stderr);
}
else if (ch == 3) /* CTRL+C */ {
/* _getch() bypasses Ctrl+C but not Ctrl+Break detection! */
fputs("^C\n", stderr);
fflush(stderr);
exit(-1);
}
else if (ch == 26) /* CTRL+Z */ {
fputs("^Z\n", stderr);
fflush(stderr);
return NULL;
}
else if (ch == 27) /* ESC */ {
fputc('\n', stderr);
fputs(prompt, stderr);
fflush(stderr);
n = 0;
}
else if ((n < sizeof(password) - 1) && !iscntrl(ch)) {
password[n++] = ch;
fputc(' ', stderr);
fflush(stderr);
}
else {
fputc('\a', stderr);
fflush(stderr);
}
}
fputc('\n', stderr);
fflush(stderr);
password[n] = '\0';
return password;
}
#else
/* linux/hpux/solaris getpass() prototype lives here */
#include <unistd.h>
#include <termios.h>
/* from apr_getpass.c */
#if defined(SIGAR_HPUX)
# define getpass termios_getpass
#elif defined(SIGAR_SOLARIS)
# define getpass getpassphrase
#endif
#ifdef SIGAR_HPUX
static char *termios_getpass(const char *prompt)
{
struct termios attr;
static char password[MAX_STRING_LEN];
unsigned int n=0;
fputs(prompt, stderr);
fflush(stderr);
if (tcgetattr(STDIN_FILENO, &attr) != 0) {
return NULL;
}
attr.c_lflag &= ~(ECHO);
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &attr) != 0) {
return NULL;
}
while ((password[n] = getchar()) != '\n') {
if (n < (sizeof(password) - 1) &&
(password[n] >= ' ') &&
(password[n] <= '~'))
{
n++;
}
else {
fprintf(stderr, "\n");
fputs(prompt, stderr);
fflush(stderr);
n = 0;
}
}
password[n] = '\0';
printf("\n");
if (n > (MAX_STRING_LEN - 1)) {
password[MAX_STRING_LEN - 1] = '\0';
}
attr.c_lflag |= ECHO;
tcsetattr(STDIN_FILENO, TCSANOW, &attr);
return (char *)&password;
}
#endif
SIGAR_DECLARE(char *) sigar_password_get(const char *prompt)
{
char *buf = NULL;
/* the linux version of getpass prints the prompt to the tty; ok.
* the solaris version prints the prompt to stderr; not ok.
* so print the prompt to /dev/tty ourselves if possible (always should be)
*/
FILE *tty = NULL;
if ((tty = fopen("/dev/tty", "w"))) {
fprintf(tty, "%s", prompt);
fflush(tty);
buf = getpass(tty ? "" : prompt);
fclose(tty);
}
return buf;
}
#endif /* WIN32 */
Jump to Line
Something went wrong with that request. Please try again.