/* Copyright (C) 2007 Henry Zhang
   This file is part of LibGTop 2.20.

   Contributed by Henry Zhang <hua.zhang@sun.com>, October 2007. 

   LibGTop is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License,
   or (at your option) any later version.

   LibGTop is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.

   You should have received a copy of the GNU General Public License
   along with LibGTop; see the file COPYING. If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#include <config.h>
#include <glibtop.h>
#include <glibtop/error.h>
#include <glibtop/netload.h>

#include "glibtop_private.h"

#include <errno.h>
#include <string.h>
#include <kstat.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/sockio.h>

#include <net/if.h>


static const unsigned long _glibtop_sysdeps_netload =
(1L << GLIBTOP_NETLOAD_ERRORS_IN) +
(1L << GLIBTOP_NETLOAD_ERRORS_OUT) +
(1L << GLIBTOP_NETLOAD_COLLISIONS);

static const unsigned long _glibtop_sysdeps_netload_data =
(1L << GLIBTOP_NETLOAD_ADDRESS) +
(1L << GLIBTOP_NETLOAD_SUBNET) +
(1L << GLIBTOP_NETLOAD_MTU);

static const unsigned long _glibtop_sysdeps_netload_bytes =
(1L << GLIBTOP_NETLOAD_BYTES_IN) +
(1L << GLIBTOP_NETLOAD_BYTES_OUT) +
(1L << GLIBTOP_NETLOAD_BYTES_TOTAL);

static const unsigned long _glibtop_sysdeps_netload_packets =
(1L << GLIBTOP_NETLOAD_PACKETS_IN) +
(1L << GLIBTOP_NETLOAD_PACKETS_OUT) +
(1L << GLIBTOP_NETLOAD_PACKETS_TOTAL);

static const unsigned long _glibtop_sysdeps_netload_total =
(1L << GLIBTOP_NETLOAD_PACKETS_TOTAL) +
(1L << GLIBTOP_NETLOAD_BYTES_TOTAL);

static const unsigned long _glibtop_sysdeps_netload_in =
(1L << GLIBTOP_NETLOAD_PACKETS_TOTAL) +
(1L << GLIBTOP_NETLOAD_BYTES_TOTAL) +
(1L << GLIBTOP_NETLOAD_PACKETS_IN) +
(1L << GLIBTOP_NETLOAD_BYTES_IN);

static const unsigned long _glibtop_sysdeps_netload_out =
(1L << GLIBTOP_NETLOAD_PACKETS_TOTAL) +
(1L << GLIBTOP_NETLOAD_BYTES_TOTAL) +
(1L << GLIBTOP_NETLOAD_PACKETS_OUT) +
(1L << GLIBTOP_NETLOAD_BYTES_OUT);

static const unsigned long _glibtop_sysdeps_netload_6 =
(1L << GLIBTOP_NETLOAD_ADDRESS6) +
(1L << GLIBTOP_NETLOAD_PREFIX6) +
(1L << GLIBTOP_NETLOAD_SCOPE6);

/* Init function. */

void
_glibtop_init_netload_s (glibtop *server)
{
        server->sysdeps.netload = _glibtop_sysdeps_netload |
	_glibtop_sysdeps_netload_bytes |
	_glibtop_sysdeps_netload_packets;
}

static int
solaris_stats(glibtop *server,
		glibtop_netload *buf,
		const char *interface)
{
	char	*name = interface;
	char	*module;
	char	*ptr;
    	kstat_ctl_t * const kctl = server->machine->kc;
	kstat_t			*ksp;
	kstat_named_t		*kdata;
	int have_bytes = 1;

	/*
	 *  chop off the trailing interface
	 */
	module = strdup( name );
	ptr = module + strlen( module ) - 1;
	while( (ptr > module) && isdigit( (int) *ptr ) ) {
		*ptr = '\0';
		ptr--;
	}

	/*
	 *  get a kstat handle and update the user's kstat chain
	 */
	if( kctl == NULL ){
		glibtop_warn_io_r (server, "kstat_open ()");
		free( module );
		return( 0 );
	}
	while( kstat_chain_update( kctl ) != 0 )
		;

	/*
	 *  traverse the kstat chain
	 *  to find the appropriate statistics
	 */
	if( (ksp = kstat_lookup( kctl,
			module, 0, name )) == NULL ) {
		free( module );
		return( 0 );
	}
	if( kstat_read( kctl, ksp, NULL ) == -1 ) {
		free( module );
		return( 0 );
	}
	free( module );

	/*
	 *  lookup & store the data
	 */
	kdata = (kstat_named_t *) kstat_data_lookup( ksp, "ipackets" );
	if( kdata != NULL ) {
		buf->packets_in= kdata->value.ul;
	}
	kdata = (kstat_named_t *) kstat_data_lookup( ksp, "opackets" );
	if( kdata != NULL ) {
		buf->packets_out = kdata->value.ul;
	}
	kdata = (kstat_named_t *) kstat_data_lookup( ksp, "rbytes" );
	if( kdata != NULL ) {
		buf->bytes_in =kdata->value.ul;
	}
	kdata = (kstat_named_t *) kstat_data_lookup( ksp, "obytes" );
	if( kdata != NULL ) {
		buf->bytes_out =kdata->value.ul;
	}
	kdata = (kstat_named_t *) kstat_data_lookup( ksp, "ierrors" );
	if( kdata != NULL ) {
		buf->errors_in = kdata->value.ul;
	}
	kdata = (kstat_named_t *) kstat_data_lookup( ksp, "oerrors" );
	if( kdata != NULL ) {
		buf->errors_out = kdata->value.ul;
	}
	kdata = (kstat_named_t *) kstat_data_lookup( ksp, "collisions" );
	if( kdata != NULL ) {
		buf->collisions = kdata->value.ul;
	}
	
	/* Compute total valules. */

	buf->bytes_total = buf->bytes_in + buf->bytes_out;
	buf->packets_total = buf->packets_in + buf->packets_out;
	buf->errors_total = buf->errors_in + buf->errors_out;
	/* And now the flags. */
	buf->flags |= _glibtop_sysdeps_netload;
	buf->flags |= _glibtop_sysdeps_netload_bytes;
	buf->flags |= _glibtop_sysdeps_netload_packets;
	    
	/* finished */
}

/* Provides network statistics. */

void
glibtop_get_netload_s (glibtop *server, glibtop_netload *buf,
		       const char *interface)
{
   int skfd;
    memset (buf, 0, sizeof (glibtop_netload));

    /* set flag */
    skfd = socket (PF_INET, SOCK_DGRAM, 0);
    if (skfd) {
	struct ifreq ifr;

	g_strlcpy (ifr.ifr_name, interface, sizeof ifr.ifr_name);
	if (ioctl (skfd, SIOCGIFFLAGS, &ifr) >= 0) {
	    const unsigned long long flags = ifr.ifr_flags;

	    buf->flags |= (1L << GLIBTOP_NETLOAD_IF_FLAGS);

	    if (flags & IFF_UP)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_UP);

	    if (flags & IFF_BROADCAST)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_BROADCAST);

	    if (flags & IFF_DEBUG)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_DEBUG);

	    if (flags & IFF_LOOPBACK)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LOOPBACK);

	    if (flags & IFF_POINTOPOINT)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_POINTOPOINT);

	    if (flags & IFF_RUNNING)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_RUNNING);

	    if (flags & IFF_NOARP)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_NOARP);

	    if (flags & IFF_PROMISC)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_PROMISC);

	    if (flags & IFF_ALLMULTI)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_ALLMULTI);

	    if (flags & IFF_MULTICAST)
		buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_MULTICAST);
	    }

	g_strlcpy (ifr.ifr_name, interface, sizeof ifr.ifr_name);
	if (!ioctl (skfd, SIOCGIFADDR, &ifr)) {
	    buf->address = ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr;
	    buf->flags |= (1L << GLIBTOP_NETLOAD_ADDRESS);
	}

	g_strlcpy (ifr.ifr_name, interface, sizeof ifr.ifr_name);
	if (!ioctl (skfd, SIOCGIFNETMASK, &ifr)) {
	    buf->subnet = ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr;
	    buf->flags |= (1L << GLIBTOP_NETLOAD_SUBNET);
	}
	close (skfd);
    }

    /*
     * Statistics
     */
     
    solaris_stats(server, buf, interface);

}