/*
 * 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 */
