/* Portions of this file are subject to the following copyright(s). See
* the Net-SNMP's COPYING file for more details and other copyrights
* that may apply:
*/
/*
* Portions of this file are copyrighted by:
* Copyright © 2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms specified in the COPYING file
* distributed with the Net-SNMP package.
*/
/*
* Host Resources MIB - system group implementation - hr_system.c
*
*/
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-features.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/data_access/swrun.h>
#include "host.h"
#include "host_res.h"
#include "hr_system.h"
#include <net-snmp/agent/auto_nlist.h>
#ifdef HAVE_SYS_PROC_H
#include <sys/param.h>
#include "sys/proc.h"
#endif
#ifndef mingw32
#if HAVE_UTMPX_H
#include <utmpx.h>
#else
#include <utmp.h>
#endif
#endif /* mingw32 */
#include <signal.h>
#include <errno.h>
#ifdef WIN32
#include <lm.h>
#endif
#ifdef linux
#ifdef HAVE_LINUX_TASKS_H
#include <linux/tasks.h>
#else
/*
* If this file doesn't exist, then there is no hard limit on the number
* of processes, so return 0 for hrSystemMaxProcesses.
*/
#define NR_TASKS 0
#endif
#endif
#if defined(hpux10) || defined(hpux11)
#include <sys/pstat.h>
#endif
#if defined(solaris2)
#include <kstat.h>
#include <sys/var.h>
#include <time.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/openpromio.h>
#endif
#ifdef HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif
netsnmp_feature_require(date_n_time)
#if !defined(UTMP_FILE) && defined(_PATH_UTMP)
#define UTMP_FILE _PATH_UTMP
#endif
#if defined(UTMP_FILE) && !HAVE_UTMPX_H
void setutent(void);
void endutent(void);
struct utmp *getutent(void);
#endif /* UTMP_FILE */
/*********************
*
* Kernel & interface information,
* and internal forward declarations
*
*********************/
#if defined(solaris2)
static struct openpromio * op_malloc(size_t size);
static void op_free(struct openpromio *op);
#ifndef NETSNMP_NO_WRITE_SUPPORT
static int set_solaris_bootcommand_parameter(int action, u_char * var_val, u_char var_val_type, size_t var_val_len, u_char * statP, oid * name, size_t name_len);
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
static int set_solaris_eeprom_parameter(const char *key, const char *value, size_t value_len);
static int get_solaris_eeprom_parameter(const char *parameter, char *output);
static long get_max_solaris_processes(void);
#endif
static int get_load_dev(void);
static int count_users(void);
extern int count_processes(void);
#if USING_HOST_DATA_ACCESS_SWRUN_MODULE
static int count_kthreads = 1;
static void parse_count_kthreads(const char *token, const char *line)
{
count_kthreads = atoi(line);
}
#endif
/*********************
*
* Initialisation & common implementation functions
*
*********************/
#define HRSYS_UPTIME 1
#define HRSYS_DATE 2
#define HRSYS_LOAD_DEV 3
#define HRSYS_LOAD_PARAM 4
#define HRSYS_USERS 5
#define HRSYS_PROCS 6
#define HRSYS_MAXPROCS 7
#if defined(solaris2)
#ifndef NETSNMP_NO_WRITE_SUPPORT
struct variable2 hrsystem_variables[] = {
{HRSYS_UPTIME, ASN_TIMETICKS, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {1}},
{HRSYS_DATE, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
var_hrsys, 1, {2}},
{HRSYS_LOAD_DEV, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {3}},
{HRSYS_LOAD_PARAM, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
var_hrsys, 1, {4}},
{HRSYS_USERS, ASN_GAUGE, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {5}},
{HRSYS_PROCS, ASN_GAUGE, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {6}},
{HRSYS_MAXPROCS, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {7}}
};
#else /* !NETSNMP_NO_WRITE_SUPPORT */
struct variable2 hrsystem_variables[] = {
{HRSYS_UPTIME, ASN_TIMETICKS, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {1}},
{HRSYS_DATE, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {2}},
{HRSYS_LOAD_DEV, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {3}},
{HRSYS_LOAD_PARAM, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {4}},
{HRSYS_USERS, ASN_GAUGE, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {5}},
{HRSYS_PROCS, ASN_GAUGE, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {6}},
{HRSYS_MAXPROCS, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {7}}
};
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
#else
struct variable2 hrsystem_variables[] = {
{HRSYS_UPTIME, ASN_TIMETICKS, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {1}},
{HRSYS_DATE, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {2}},
{HRSYS_LOAD_DEV, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {3}},
{HRSYS_LOAD_PARAM, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {4}},
{HRSYS_USERS, ASN_GAUGE, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {5}},
{HRSYS_PROCS, ASN_GAUGE, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {6}},
{HRSYS_MAXPROCS, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrsys, 1, {7}}
};
#endif
oid hrsystem_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 1 };
void
init_hr_system(void)
{
#ifdef NPROC_SYMBOL
auto_nlist(NPROC_SYMBOL, 0, 0);
#endif
#if USING_HOST_DATA_ACCESS_SWRUN_MODULE
snmpd_register_const_config_handler("count_kthreads",
parse_count_kthreads, NULL,
"0|1 0 to exclude kernel threads from hrSystemProcesses.0");
#endif
REGISTER_MIB("host/hr_system", hrsystem_variables, variable2,
hrsystem_variables_oid);
} /* end init_hr_system */
/*
* header_hrsys(...
* Arguments:
* vp IN - pointer to variable entry that points here
* name IN/OUT - IN/name requested, OUT/name found
* length IN/OUT - length of IN/OUT oid's
* exact IN - TRUE if an exact match was requested
* var_len OUT - length of variable or 0 if function returned
* write_method
*/
int
header_hrsys(struct variable *vp,
oid * name,
size_t * length,
int exact, size_t * var_len, WriteMethod ** write_method)
{
#define HRSYS_NAME_LENGTH 9
oid newname[MAX_OID_LEN];
int result;
DEBUGMSGTL(("host/hr_system", "var_hrsys: "));
DEBUGMSGOID(("host/hr_system", name, *length));
DEBUGMSG(("host/hr_system", " %d\n", exact));
memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
newname[HRSYS_NAME_LENGTH] = 0;
result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
if ((exact && (result != 0)) || (!exact && (result >= 0)))
return (MATCH_FAILED);
memcpy((char *) name, (char *) newname,
(vp->namelen + 1) * sizeof(oid));
*length = vp->namelen + 1;
*write_method = (WriteMethod*)0;
*var_len = sizeof(long); /* default to 'long' results */
return (MATCH_SUCCEEDED);
} /* end header_hrsys */
/*********************
*
* System specific implementation functions
*
*********************/
u_char *
var_hrsys(struct variable * vp,
oid * name,
size_t * length,
int exact, size_t * var_len, WriteMethod ** write_method)
{
static char string[129]; /* per MIB, max size is 128 */
#if defined(solaris2)
/* max size of nvram property */
char bootparam[8192];
#endif
time_t now;
#ifdef linux
FILE *fp;
#endif
#if NETSNMP_CAN_USE_SYSCTL && defined(CTL_KERN) && defined(KERN_MAXPROC)
static int maxproc_mib[] = { CTL_KERN, KERN_MAXPROC };
size_t buf_size;
#endif
#if defined(hpux10) || defined(hpux11)
struct pst_static pst_buf;
#endif
if (header_hrsys(vp, name, length, exact, var_len, write_method) ==
MATCH_FAILED)
return NULL;
switch (vp->magic) {
case HRSYS_UPTIME:
long_return = get_uptime();
return (u_char *) & long_return;
case HRSYS_DATE:
#if defined(HAVE_MKTIME) && defined(HAVE_STIME)
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method=ns_set_time;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
#endif
time(&now);
return (u_char *) date_n_time(&now, var_len);
case HRSYS_LOAD_DEV:
long_return = get_load_dev();
return (u_char *) & long_return;
case HRSYS_LOAD_PARAM:
#ifdef linux
if((fp = fopen("/proc/cmdline", "r")) != NULL) {
fgets(string, sizeof(string), fp);
fclose(fp);
} else {
return NULL;
}
#elif defined(solaris2)
#ifndef NETSNMP_NO_WRITE_SUPPORT
*write_method=set_solaris_bootcommand_parameter;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
if ( get_solaris_eeprom_parameter("boot-command",bootparam) ) {
snmp_log(LOG_ERR,"unable to lookup boot-command from eeprom\n");
return NULL;
}
strlcpy(string,bootparam,sizeof(string));
#else
#if NETSNMP_NO_DUMMY_VALUES
return NULL;
#endif
sprintf(string, "ask Dave"); /* XXX */
#endif
*var_len = strlen(string);
return (u_char *) string;
case HRSYS_USERS:
long_return = count_users();
return (u_char *) & long_return;
case HRSYS_PROCS:
#if USING_HOST_DATA_ACCESS_SWRUN_MODULE
long_return = swrun_count_processes(count_kthreads);
#elif USING_HOST_HR_SWRUN_MODULE
long_return = count_processes();
#else
#if NETSNMP_NO_DUMMY_VALUES
return NULL;
#endif
long_return = 0;
#endif
return (u_char *) & long_return;
case HRSYS_MAXPROCS:
#if defined(NR_TASKS)
long_return = NR_TASKS; /* <linux/tasks.h> */
#elif NETSNMP_CAN_USE_SYSCTL && defined(CTL_KERN) && defined(KERN_MAXPROC)
{
int nproc = 0;
buf_size = sizeof(nproc);
if (sysctl(maxproc_mib, 2, &nproc, &buf_size, NULL, 0) < 0)
return NULL;
long_return = nproc;
}
#elif defined(hpux10) || defined(hpux11)
pstat_getstatic(&pst_buf, sizeof(struct pst_static), 1, 0);
long_return = pst_buf.max_proc;
#elif defined(solaris2)
long_return = get_max_solaris_processes();
if (long_return == -1)
return NULL;
#elif defined(NPROC_SYMBOL)
{
int nproc = 0;
auto_nlist(NPROC_SYMBOL, (char *) &nproc, sizeof(nproc));
long_return = nproc;
}
#else
#if NETSNMP_NO_DUMMY_VALUES
return NULL;
#endif
long_return = 0;
#endif
return (u_char *) & long_return;
default:
DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrsys\n",
vp->magic));
}
return NULL;
} /* end var_hrsys */
/*********************
*
* Internal implementation functions
*
*********************/
#if defined(solaris2)
/* functions for malloc and freeing openpromio structure */
static struct openpromio * op_malloc(size_t size)
{
struct openpromio *op;
op=malloc(sizeof(struct openpromio) + size);
if(op == NULL) {
snmp_log(LOG_ERR,"unable to malloc memory\n");
return NULL;
}
memset(op, 0, sizeof(struct openpromio)+size);
op->oprom_size=size;
return op;
}
static void op_free(struct openpromio *op) {
free(op);
}
#ifndef NETSNMP_NO_WRITE_SUPPORT
static int
set_solaris_bootcommand_parameter(int action,
u_char * var_val,
u_char var_val_type,
size_t var_val_len,
u_char * statP, oid * name, size_t name_len) {
static char old_value[1024],*p_old_value=old_value;
int status=0;
switch (action) {
case RESERVE1:
/* check type */
if (var_val_type != ASN_OCTET_STR) {
snmp_log(LOG_ERR,"write to set_solaris_bootcommand_parameter not ASN_OCTET_STR\n");
return SNMP_ERR_WRONGTYPE;
}
break;
case RESERVE2: {
/* create copy of old value */
if(statP) {
int old_val_len=strlen(statP);
if(old_val_len >= sizeof(old_value)) {
p_old_value=(char *)malloc(old_val_len+1);
if(p_old_value==NULL) {
snmp_log(LOG_ERR,"unable to malloc memory\n");
return SNMP_ERR_GENERR;
}
}
strlcpy(p_old_value,statP,old_val_len+1);
} else {
p_old_value=NULL;
}
break;
}
case ACTION: {
status=set_solaris_eeprom_parameter("boot-command",(char *)var_val,var_val_len);
if(status!=0) return SNMP_ERR_GENERR;
break;
}
case UNDO: {
/* revert to old value */
if(p_old_value) {
status=set_solaris_eeprom_parameter("boot-command",(char *)p_old_value,strlen(p_old_value));
p_old_value=old_value;
if(status!=0) return SNMP_ERR_GENERR;
}
break;
}
case FREE:
case COMMIT:
/* free memory if necessary */
if(p_old_value != old_value) {
free(p_old_value);
p_old_value=old_value;
}
break;
}
return SNMP_ERR_NOERROR;
}
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
static int set_solaris_eeprom_parameter(const char *key, const char *value,
size_t var_val_len) {
int status=0;
char buffer[1024],*pbuffer=buffer;
if( strlen(key)+strlen(value)+16 > sizeof(buffer) ) {
pbuffer=(char *)malloc(strlen(key)+strlen(value)+16);
}
sprintf(pbuffer, "eeprom %s=\"%.*s\"\n", key, var_val_len, value);
status=system(pbuffer);
if(pbuffer!=buffer) free(pbuffer);
return status;
}
static int get_solaris_eeprom_parameter(const char *parameter, char *outbuffer) {
int fd=0,status=0;
struct openpromio *openprominfo=NULL;
fd=open("/dev/openprom",O_RDONLY);
if ( fd == -1 ) {
snmp_log_perror("/dev/openprom");
return 1;
}
openprominfo = op_malloc(8192);
if(!openprominfo) return 1;
strcpy(openprominfo->oprom_array,parameter);
status=ioctl(fd,OPROMGETOPT,openprominfo);
if ( status == -1 ) {
snmp_log_perror("/dev/openprom");
close(fd);
op_free(openprominfo);
return 1;
}
strcpy(outbuffer,openprominfo->oprom_array);
op_free(openprominfo);
/* close file */
close(fd);
return(0);
}
static long get_max_solaris_processes(void) {
kstat_ctl_t *ksc=NULL;
kstat_t *ks=NULL;
struct var v;
static long maxprocs=-1;
/* assume only necessary to compute once, since /etc/system must be modified */
if (maxprocs == -1) {
if ( (ksc=kstat_open()) != NULL &&
(ks=kstat_lookup(ksc, "unix", 0, "var")) != NULL &&
(kstat_read(ksc, ks, &v) != -1)) {
maxprocs=v.v_proc;
}
if(ksc) {
kstat_close(ksc);
}
}
return maxprocs;
}
#endif
#if defined(HAVE_MKTIME) && defined(HAVE_STIME)
#ifndef NETSNMP_NO_WRITE_SUPPORT
int
ns_set_time(int action,
u_char * var_val,
u_char var_val_type,
size_t var_val_len,
u_char * statP, oid * name, size_t name_len)
{
static time_t oldtime=0;
switch (action) {
case RESERVE1:
/* check type */
if (var_val_type != ASN_OCTET_STR) {
snmp_log(LOG_ERR,"write to ns_set_time not ASN_OCTET_STR\n");
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len != 8 && var_val_len!=11) {
snmp_log(LOG_ERR,"write to ns_set_time not a proper length\n");
return SNMP_ERR_WRONGVALUE;
}
break;
case RESERVE2:
break;
case FREE:
break;
case ACTION: {
long status=0;
time_t seconds=0;
struct tm newtimetm;
int hours_from_utc= 0;
int minutes_from_utc= 0;
if (var_val_len == 11) {
/* timezone inforamation was present */
hours_from_utc=(int)var_val[9];
minutes_from_utc=(int)var_val[10];
}
newtimetm.tm_sec=(int)var_val[6];
newtimetm.tm_min=(int)var_val[5];
newtimetm.tm_hour=(int)var_val[4];
newtimetm.tm_mon=(int)var_val[2]-1;
newtimetm.tm_year=256*(int)var_val[0]+(int)var_val[1]-1900;
newtimetm.tm_mday=(int)var_val[3];
/* determine if day light savings time in effect DST */
if ( ( hours_from_utc*60*60+minutes_from_utc*60 ) == abs(timezone) ) {
newtimetm.tm_isdst=0;
} else {
newtimetm.tm_isdst=1;
}
/* create copy of old value */
oldtime=time(NULL);
seconds=mktime(&newtimetm);
if(seconds == (time_t)-1) {
snmp_log(LOG_ERR, "Unable to convert time value\n");
return SNMP_ERR_GENERR;
}
#ifdef HAVE_STIME
status=stime(&seconds);
#else
status=-1;
#endif
if(status!=0) {
snmp_log(LOG_ERR, "Unable to set time\n");
return SNMP_ERR_GENERR;
}
break;
}
case UNDO: {
/* revert to old value */
int status=0;
if(oldtime != 0) {
#ifdef HAVE_STIME
status=stime(&oldtime);
#else
status=-1;
#endif
oldtime=0;
if(status!=0) {
snmp_log(LOG_ERR, "Unable to set time\n");
return SNMP_ERR_GENERR;
}
}
break;
}
case COMMIT: {
oldtime=0;
break;
}
}
return SNMP_ERR_NOERROR;
}
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
#endif
/*
* Return the DeviceIndex corresponding
* to the boot device
*/
static int
get_load_dev(void)
{
return (HRDEV_DISK << HRDEV_TYPE_SHIFT); /* XXX */
} /* end get_load_dev */
static int
count_users(void)
{
int total = 0;
#ifndef WIN32
#if HAVE_UTMPX_H
#define setutent setutxent
#define pututline pututxline
#define getutent getutxent
#define endutent endutxent
struct utmpx *utmp_p;
#else
struct utmp *utmp_p;
#endif
setutent();
while ((utmp_p = getutent()) != NULL) {
#ifndef UTMP_HAS_NO_TYPE
if (utmp_p->ut_type != USER_PROCESS)
continue;
#endif
#ifndef UTMP_HAS_NO_PID
/* This block of code skips zombie user PIDs in the
utmp/utmpx file that would otherwise be counted as a
current user, but leaves updating the actual
utmp/utmpx file to the system. */
if (kill(utmp_p->ut_pid, 0) == -1 && errno == ESRCH) {
continue;
}
#endif
++total;
}
endutent();
#else /* WIN32 */
/*
* TODO - Error checking.
*/
LPWKSTA_INFO_102 wkinfo;
NET_API_STATUS nstatus;
nstatus = NetWkstaGetInfo(NULL, 102, (LPBYTE*)&wkinfo);
if (nstatus != NERR_Success) {
return 0;
}
total = (int)wkinfo->wki102_logged_on_users;
NetApiBufferFree(wkinfo);
#endif /* WIN32 */
return total;
}
#if defined(UTMP_FILE) && !HAVE_UTMPX_H
static FILE *utmp_file;
static struct utmp utmp_rec;
void
setutent(void)
{
if (utmp_file)
fclose(utmp_file);
utmp_file = fopen(UTMP_FILE, "r");
}
void
endutent(void)
{
if (utmp_file) {
fclose(utmp_file);
utmp_file = NULL;
}
}
struct utmp *
getutent(void)
{
if (!utmp_file)
return NULL;
while (fread(&utmp_rec, sizeof(utmp_rec), 1, utmp_file) == 1)
if (*utmp_rec.ut_name && *utmp_rec.ut_line)
return &utmp_rec;
return NULL;
}
#endif /* UTMP_FILE */