pool/net-snmp
SHA256
2
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
3c1595c335
net-snmp/net-snmp-5.9.1-velocity-mib.patch
Alexander Bergmann b2dc2d3287 Accepting request 966059 from home:abergmann:net-snmp:Factory 
- Decouple snmp-mibs from net-snmp version to allow major version
  upgrade (bsc#1196955).
- Fix LFH violation during v3 user creation (bsc#1181591).
  Add net-snmp-5.9.1-fix-create-v3-user-outfile.patch
- Fix subagent crash at save_set_var() (bsc#1178021).
  Add net-snmp-5.9.1-subagent-set-response.patch
- Fix missing sysconfig files creation (bsc#1108471). 
- Rename patches to version number 5.9.1:
  delete:
  * net-snmp-5.8-socket-path.patch
  * net-snmp-5.8-testing-empty-arptable.patch
  * net-snmp-5.8-pie.patch
  * net-snmp-5.8-net-snmp-config-headercheck.patch
  * net-snmp-5.8-perl-tk-warning.patch
  * net-snmp-5.8-velocity-mib.patch
  * net-snmp-5.8-snmpstatus-suppress-output.patch
  * net-snmp-5.8-fix-Makefile.PL.patch
  * net-snmp-5.8-modern-rpm-api.patch
  add:
  * net-snmp-5.9.1-socket-path.patch
  * net-snmp-5.9.1-testing-empty-arptable.patch
  * net-snmp-5.9.1-pie.patch
  * net-snmp-5.9.1-net-snmp-config-headercheck.patch
  * net-snmp-5.9.1-perl-tk-warning.patch
  * net-snmp-5.9.1-velocity-mib.patch
  * net-snmp-5.9.1-snmpstatus-suppress-output.patch
  * net-snmp-5.9.1-fix-Makefile.PL.patch
  * net-snmp-5.9.1-modern-rpm-api.patch

OBS-URL: https://build.opensuse.org/request/show/966059
OBS-URL: https://build.opensuse.org/package/show/network:utilities/net-snmp?expand=0&rev=42
2022-03-31 07:50:07 +00:00

3374 lines
103 KiB
Diff
Raw Blame History

Index: net-snmp-5.7.2/LICENSE.VELOCITY
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/LICENSE.VELOCITY
@@ -0,0 +1,41 @@
+/* Portions of these files 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 these files 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.
+ */
+/*
+ * Copyright © 2002-2008, Velocity Software, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ ** Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ ** Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ ** Neither the name of the Velocity Software, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
Index: net-snmp-5.7.2/agent/mibgroup/velocity.h
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/agent/mibgroup/velocity.h
@@ -0,0 +1,28 @@
+/*
+ * Velocity 'wrapper' interface which is an extension of the host resources
+ * calls the per-group interfaces from 'hr_*.h' and 'velocity_*.h'
+ */
+
+ config_require(host/hr_system)
+ config_require(velocity/velocity_system)
+ config_require(host/hrh_storage)
+ config_require(host/hr_device)
+ config_require(host/hr_other)
+ config_require(host/hr_proc)
+ config_require(host/hr_network)
+ config_require(host/hr_print)
+ config_require(host/hr_disk)
+ config_require(host/hr_partition)
+ config_require(host/hrh_filesys)
+ config_require(velocity/velocity_swrun)
+ config_require(host/hr_swrun)
+ config_require(host/hr_swinst)
+ config_require(velocity/velocity_app)
+/* config_require(ucd-snmp/proc) */
+
+/* add the host resources mib to the default mibs to load */
+config_add_mib(HOST-RESOURCES-MIB)
+config_add_mib(HOST-RESOURCES-TYPES)
+config_add_mib(UCD-SNMP-MIB)
+config_add_mib(VELOCITY-MIB)
+config_add_mib(VELOCITY-TYPES)
Index: net-snmp-5.7.2/agent/mibgroup/velocity/velocity_app.c
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/agent/mibgroup/velocity/velocity_app.c
@@ -0,0 +1,499 @@
+#include <net-snmp/net-snmp-config.h>
+
+#ifdef solaris2
+#define _KMEMUSER /* Needed by <sys/user.h> */
+#include <sys/types.h> /* helps define struct rlimit */
+#endif
+
+#if HAVE_IO_H /* win32 */
+#include <io.h>
+#endif
+#if HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if HAVE_STRING_H
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+#if HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+#include <math.h>
+#include <ctype.h>
+#include <sys/types.h>
+#if HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#if TIME_WITH_SYS_TIME
+# ifdef WIN32
+# include <sys/timeb.h>
+# else
+# include <sys/time.h>
+# endif
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+# include <sys/time.h>
+# else
+# include <time.h>
+# endif
+#endif
+#if HAVE_KVM_H
+#include <kvm.h>
+#endif
+#if HAVE_WINSOCK_H
+#include <winsock.h>
+#endif
+
+#if HAVE_DMALLOC_H
+#include <dmalloc.h>
+#endif
+
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+#include "struct.h"
+#include "velocity_app.h"
+#ifdef USING_UCD_SNMP_ERRORMIB_MODULE
+#include "../ucd-snmp/errormib.h"
+#else
+#define setPerrorstatus(x) snmp_log_perror(x)
+#endif
+#include "util_funcs.h"
+#include "kernel.h"
+#include "errno.h"
+
+static struct myvelocityApp *get_velocityApp_instance(struct myvelocityApp *, oid);
+struct myvelocityApp *velocityAppwatch = NULL;
+int numvelocityApps = 0;
+#define ID_SIZE 300
+
+void
+init_velocity_app(void)
+{
+
+ /*
+ * define the structure we're going to ask the agent to register our
+ * information at
+ */
+ struct variable2 extensible_velocityApp_variables[] = {
+ {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_velocityApp, 1, {MIBINDEX}},
+ {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_velocityApp, 1,
+ {ERRORNAME}},
+ {APPPID, ASN_OCTET_STR, RONLY, var_extensible_velocityApp, 1, {APPPID}},
+ {APPMIN, ASN_INTEGER, RONLY, var_extensible_velocityApp, 1, {APPMIN}},
+ {APPMAX, ASN_INTEGER, RONLY, var_extensible_velocityApp, 1, {APPMAX}},
+ {APPCOUNT, ASN_INTEGER, RONLY, var_extensible_velocityApp, 1,
+ {APPCOUNT}},
+ {APPIDS, ASN_OCTET_STR, RONLY, var_extensible_velocityApp, 1,
+ {APPIDS}},
+ {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_velocityApp, 1,
+ {ERRORFLAG}},
+ {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_velocityApp, 1,
+ {ERRORMSG}},
+ };
+
+ /*
+ * Define the OID pointer to the top of the mib tree that we're
+ * registering underneath
+ */
+ oid velocityApp_variables_oid[] = { 1, 3, 6, 1, 4, 1, 15601, 6, 1 };
+
+ /*
+ * register ourselves with the agent to handle our mib tree
+ */
+ REGISTER_MIB("velocity/velocity_app", extensible_velocityApp_variables, variable2,
+ velocityApp_variables_oid);
+
+ snmpd_register_config_handler("app", velocityApp_parse_config,
+ velocityApp_free_config,
+ "application-name [max-num] [min-num]");
+}
+
+
+
+/*
+ * Define snmpd.conf reading routines first. They get called
+ * automatically by the invocation of a macro in the proc.h file.
+ */
+
+void
+velocityApp_free_config(void)
+{
+ struct myvelocityApp *ptmp, *ptmp2;
+
+ for (ptmp = velocityAppwatch; ptmp != NULL;) {
+ ptmp2 = ptmp;
+ ptmp = ptmp->next;
+ free(ptmp2);
+ }
+ velocityAppwatch = NULL;
+ numvelocityApps = 0;
+}
+
+/*
+ * find a give entry in the linked list associated with a proc name
+ */
+static struct myvelocityApp *
+get_velocityApp_by_name(char *name)
+{
+ struct myvelocityApp *ptmp;
+
+ if (name == NULL)
+ return NULL;
+
+ for (ptmp = velocityAppwatch; ptmp != NULL && strcmp(ptmp->name, name) != 0;
+ ptmp = ptmp->next);
+ return ptmp;
+}
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+void
+velocityApp_parse_config(const char *token, char *cptr)
+{
+ char tmpname[STRMAX];
+ char tmppid[STRMAX];
+ struct myvelocityApp **procp = &velocityAppwatch;
+ struct stat stat_buf;
+ const char none[] = "NONE";
+ int statrc, retc;
+ char *tmpstr;
+
+ /*
+ * don't allow two entries with the same name
+ */
+ /* retc = strcpy(tmpstr,cptr); */
+ tmpstr = cptr;
+ copy_nword(tmpstr, tmpname, sizeof(tmpname));
+ if (get_velocityApp_by_name(tmpname) != NULL) {
+ config_perror("Already have an entry for this process.");
+ return;
+ }
+ DEBUGMSGTL(("velocity/velocity_app", "tmpname = %s \n", tmpname));
+ tmpstr = skip_not_white(tmpstr);
+ tmpstr = skip_white(tmpstr);
+ copy_nword(tmpstr, tmppid, sizeof(tmppid));
+ retc = strcmp(tmppid, none);
+ DEBUGMSGTL(("velocity/velocity_app", "tmppid = %s retc = %d\n", tmppid, retc));
+ statrc = stat(tmppid, &stat_buf);
+ DEBUGMSGTL(("velocity/velocity_app", "tmppid = %s statrc = %d st_mode = %d\n", tmppid, statrc, S_ISREG(stat_buf.st_mode)));
+ if (retc == 0 || S_ISREG(stat_buf.st_mode)) {
+ DEBUGMSGTL(("velocity/velocity_app", "Valid app string %s %s\n", tmpname, tmppid));
+ }
+ else {
+ config_perror("Incorrect syntax for app statement. Must give either keyword NONE or absolute file.");
+ return;
+ }
+
+ /*
+ * skip past used ones
+ */
+ while (*procp != NULL)
+ procp = &((*procp)->next);
+
+ (*procp) = (struct myvelocityApp *) calloc(1, sizeof(struct myvelocityApp));
+ if (*procp == NULL)
+ return; /* memory alloc error */
+ numvelocityApps++;
+ /*
+ * not blank and not a comment
+ */
+ copy_nword(cptr, (*procp)->name, sizeof((*procp)->name));
+ cptr = skip_not_white(cptr);
+ cptr = skip_white(cptr);
+ copy_nword(cptr, (*procp)->pidfile, sizeof((*procp)->pidfile));
+ DEBUGMSGTL(("velocity/velocity_app", "Read: %s %s\n",
+ (*procp)->name, (*procp)->pidfile));
+ cptr = skip_not_white(cptr);
+ if ((cptr = skip_white(cptr))) {
+ (*procp)->max = atoi(cptr);
+ cptr = skip_not_white(cptr);
+ if ((cptr = skip_white(cptr)))
+ (*procp)->min = atoi(cptr);
+ else
+ (*procp)->min = 0;
+ } else {
+ (*procp)->max = 0;
+ (*procp)->min = 0;
+ }
+ DEBUGMSGTL(("velocity/velocity_app", "Read: %s (%d) (%d)\n",
+ (*procp)->name, (*procp)->max, (*procp)->min));
+}
+
+
+static struct myvelocityApp *
+get_velocityApp_instance(struct myvelocityApp *proc, oid inst)
+{
+ int i;
+
+ if (proc == NULL)
+ return (NULL);
+ for (i = 1; (i != (int) inst) && (proc != NULL); i++)
+ proc = proc->next;
+ return (proc);
+}
+#include <dirent.h>
+#include <fcntl.h>
+
+/*
+ * The routine that handles everything
+ */
+
+u_char *
+var_extensible_velocityApp(struct variable *vp,
+ oid * name,
+ size_t * length,
+ int exact,
+ size_t * var_len, WriteMethod ** write_method)
+{
+
+ DIR *dir;
+ struct myvelocityApp *proc;
+ static long long_ret;
+ static char errmsg[ID_SIZE];
+
+ char * cmdline = NULL;
+ struct dirent *ent;
+ static char fn[19];
+ FILE * fd;
+ char temp[ID_SIZE];
+ size_t len = 0;
+ ssize_t read;
+ int statrc, retc;
+ struct stat stat_buff;
+ const char none[] = "NONE";
+ char * temp2;
+
+ if (header_simple_table
+ (vp, name, length, exact, var_len, write_method, numvelocityApps))
+ return (NULL);
+ if ((proc = get_velocityApp_instance(velocityAppwatch, name[*length - 1]))) {
+ switch (vp->magic) {
+ case MIBINDEX:
+ long_ret = name[*length - 1];
+ return ((u_char *) (&long_ret));
+ case ERRORNAME: /* process name to check for */
+ *var_len = strlen(proc->name);
+ return ((u_char *) (proc->name));
+ case APPPID:
+ *var_len = strlen(proc->pidfile);
+ DEBUGMSGTL(("velocity/velocity_app", "pid file is %s\n", proc->name ));
+ return ((u_char *) (proc->pidfile));
+ case APPMIN:
+ long_ret = proc->min;
+ return ((u_char *) (&long_ret));
+ case APPMAX:
+ long_ret = proc->max;
+ return ((u_char *) (&long_ret));
+ case APPCOUNT:
+ DEBUGMSGTL(("velocity/velocity_app", "pid file is %s\n", proc->pidfile ));
+ retc = strcmp(proc->pidfile, none);
+ DEBUGMSGTL(("velocity/velocity_app", "retc is %d, pid is %s, none is %s.\n", retc, proc->pidfile, none));
+ DEBUGMSGTL(("velocity/velocity_app", "pid length is %d, none length is %d\n",strlen(proc->pidfile), strlen(none)));
+ if ( retc == 0 || strlen(proc->pidfile) == 0 ) {
+ DEBUGMSGTL(("velocity/velocity_app", "Calling count"));
+ long_ret = sh_count_velocityApps(proc->name);
+ }
+ else {
+ if (proc->pidfile != NULL) {
+ if ((fd = fopen(proc->pidfile, "r")) == NULL) break;
+ read = getline(&cmdline, &len, fd);
+ fclose(fd);
+ if (len == -1 ) break;
+ DEBUGMSGTL(("velocity/velocity_app", "Length returned is %d\n",len));
+ DEBUGMSGTL(("velocity/velocity_app", "cmdline is %s\n",cmdline));
+ cmdline = skip_white(cmdline);
+ copy_nword(cmdline, errmsg, sizeof(errmsg));
+ sprintf(fn,"/proc/%s",errmsg);
+ DEBUGMSGTL(("velocity/velocity_app", "Filename is %s\n",fn));
+ statrc = stat(fn, &stat_buff);
+ DEBUGMSGTL(("velocity/velocity_app", "statrc = %d\n",statrc));
+ if (cmdline)
+ free(cmdline);
+ if (statrc == 0 ) {
+ DEBUGMSGTL(("velocity/velocity_app", "process found - %s\n", fn));
+ long_ret = 1;
+ }
+ else {
+ DEBUGMSGTL(("velocity/velocity_app", "process not found - %s\n",fn));
+ long_ret = 0;
+ }
+ }
+ }
+ DEBUGMSGTL(("velocity/velocity_app", "Return %d\n", long_ret));
+ return ((u_char *) (&long_ret));
+ case APPIDS:
+ if (strcmp(proc->pidfile, none) == 0 || strlen(proc->pidfile) == 0) {
+ if ((dir = opendir("/proc")) == NULL) {
+ sprintf(fn,"-1");
+ return ((u_char *) fn);
+ }
+ errmsg[0] = 0;
+ while (NULL != (ent = readdir(dir))) {
+ if(!(ent->d_name[0] >= '0' && ent->d_name[0] <= '9')) continue;
+ /* read /proc/XX/cmdline */
+ sprintf(fn,"/proc/%s/cmdline",ent->d_name);
+ if((fd = fopen(fn, "r")) == NULL) break;
+ read = getline(&cmdline,&len, fd);
+ fclose(fd);
+ if(read == -1) continue;
+ while(--read && !cmdline[read]);
+ while(--read) if(!cmdline[read]) cmdline[read] = ' ';
+ if(strstr(cmdline,proc->name) != NULL ) {
+ snprintf(temp,sizeof(errmsg),"%s %s", errmsg, ent->d_name);
+
+ strcpy(errmsg,temp);
+ }
+ }
+ closedir(dir);
+ }
+ else {
+ DEBUGMSGTL(("velocity/velocity_app", "Appid\n"));
+ if ((fd = fopen(proc->pidfile, "r")) == NULL) break;
+ read = getline(&cmdline, &len, fd);
+ fclose(fd);
+ if (len == -1 ) break;
+ cmdline = skip_white(cmdline);
+ copy_nword(cmdline, errmsg, sizeof(errmsg));
+ sprintf(fn,"/proc/%s",errmsg);
+ DEBUGMSGTL(("velocity/velocity_app", "Filename is %s\n",fn));
+ statrc = stat(fn, &stat_buff);
+ DEBUGMSGTL(("velocity/velocity_app", "statrc = %d\n",statrc));
+ if (statrc == 0 ) {
+ DEBUGMSGTL(("velocity/velocity_app", "process id is - %s \n", errmsg));
+ }
+ else {
+ DEBUGMSGTL(("velocity/velocity_app", "process id should be - %s\n", errmsg));
+ errmsg[0] = 0;
+ }
+ }
+ DEBUGMSGTL(("velocity/velocity_app", "errmsg string is %s\n", errmsg));
+ if (cmdline)
+ free(cmdline);
+ *var_len = strlen(errmsg);
+ return ((u_char *) errmsg);
+ case ERRORFLAG:
+ if (strcmp(proc->pidfile, none) == 0 || strlen(proc->pidfile) == 0) {
+ long_ret = sh_count_velocityApps(proc->name);
+ }
+ else {
+ if ((fd = fopen(proc->pidfile, "r")) == NULL) break;
+ read = getline(&cmdline, &len, fd);
+ fclose(fd);
+ if (len == -1 ) break;
+ cmdline = skip_white(cmdline);
+ copy_nword(cmdline, errmsg, sizeof(errmsg));
+ sprintf(fn,"/proc/%s",errmsg);
+ DEBUGMSGTL(("velocity/velocity_app", "Filename is %s\n",fn));
+ statrc = stat(fn, &stat_buff);
+ DEBUGMSGTL(("velocity/velocity_app", "statrc = %d\n",statrc));
+ if (cmdline)
+ free(cmdline);
+ if (statrc == 0 ) {
+ DEBUGMSGTL(("velocity/velocity_app", "process found - %s ", fn));
+ long_ret = 1;
+ }
+ else {
+ DEBUGMSGTL(("velocity/velocity_app", "process not found - %s",fn));
+ long_ret = 0;
+ }
+ }
+ if (long_ret >= 0 &&
+ ((proc->min && long_ret < proc->min) ||
+ (proc->max && long_ret > proc->max) ||
+ (proc->min == 0 && proc->max == 0 && long_ret < 1))) {
+ long_ret = 1;
+ } else {
+ long_ret = 0;
+ }
+ return ((u_char *) (&long_ret));
+ case ERRORMSG:
+ if (strcmp(proc->pidfile, none) == 0 || strlen(proc->pidfile) == 0) {
+ long_ret = sh_count_velocityApps(proc->name);
+ }
+ else {
+ if ((fd = fopen(proc->pidfile, "r")) == NULL) break;
+ read = getline(&cmdline, &len, fd);
+ fclose(fd);
+ if (len == -1 ) break;
+ cmdline = skip_white(cmdline);
+ copy_nword(cmdline, errmsg, sizeof(errmsg));
+ sprintf(fn,"/proc/%s",errmsg);
+ DEBUGMSGTL(("velocity/velocity_app", "Filename is %s\n",fn));
+ statrc = stat(fn, &stat_buff);
+ DEBUGMSGTL(("velocity/velocity_app", "statrc = %d\n",statrc));
+ if (cmdline)
+ free(cmdline);
+ if (statrc == 0 ) {
+ DEBUGMSGTL(("velocity/velocity_app", "process found - %s\n ", fn));
+ long_ret = 1;
+ }
+ else {
+ DEBUGMSGTL(("velocity/velocity_app", "process not found - %s\n",fn));
+ long_ret = 0;
+ }
+ }
+ if (long_ret < 0) {
+ errmsg[0] = 0; /* catch out of mem errors return 0 count */
+ } else if (proc->min && long_ret < proc->min) {
+ snprintf(errmsg, sizeof(errmsg),
+ "Too few %s running (# = %d)",
+ proc->name, (int) long_ret);
+ } else if (proc->max && long_ret > proc->max) {
+ snprintf(errmsg, sizeof(errmsg),
+ "Too many %s running (# = %d)",
+ proc->name, (int) long_ret);
+ } else if (proc->min == 0 && proc->max == 0 && long_ret < 1) {
+ snprintf(errmsg, sizeof(errmsg),
+ "No %s process running.", proc->name);
+ } else {
+ errmsg[0] = 0;
+ }
+ errmsg[ sizeof(errmsg)-1 ] = 0;
+ *var_len = strlen(errmsg);
+ return ((u_char *) errmsg);
+ }
+ return NULL;
+ }
+ return NULL;
+}
+
+
+int
+sh_count_velocityApps(char *velocityAppname)
+{
+ DIR *dir;
+ char *cmdline = NULL;
+ struct dirent *ent;
+ FILE *fd;
+ size_t len;
+ char fn[18];
+ int total = 0;
+
+ if ((dir = opendir("/proc")) == NULL) return -1;
+ while (NULL != (ent = readdir(dir))) {
+ if(!(ent->d_name[0] >= '0' && ent->d_name[0] <= '9')) continue;
+ /* read /proc/XX/cmdline */
+ sprintf(fn,"/proc/%s/cmdline",ent->d_name);
+ if((fd = fopen(fn, "r")) == NULL) break;
+ len = getline(&cmdline,&len,fd);
+ fclose(fd);
+ if(len == -1) continue;
+ cmdline[len] = 0;
+ while(--len && !cmdline[len]);
+ while(--len) if(!cmdline[len]) cmdline[len] = ' ';
+ if(strstr(cmdline,velocityAppname) != NULL ) total++;
+ if (cmdline)
+ free(cmdline);
+ }
+ closedir(dir);
+ return total;
+}
+
Index: net-snmp-5.7.2/agent/mibgroup/velocity/velocity_app.h
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/agent/mibgroup/velocity/velocity_app.h
@@ -0,0 +1,38 @@
+/*
+ * Application watching mib group
+ */
+#ifndef _MIBGROUP_APP_H
+#define _MIBGROUP_APP_H
+
+config_require(util_funcs)
+
+ void init_velocity_app(void);
+
+ extern FindVarMethod var_extensible_velocityApp;
+ int sh_count_velocityApps(char *);
+ int sh_list_velocityApps(char *, char *);
+
+/*
+ * config file parsing routines
+ */
+ void velocityApp_free_config(void);
+ void velocityApp_parse_config(const char *, char *);
+
+struct myvelocityApp {
+ char name[STRMAX];
+ char pidfile[STRMAX];
+ int min;
+ int max;
+ struct myvelocityApp *next;
+};
+
+
+#include "mibdefs.h"
+
+#define APPPID 3
+#define APPMIN 4
+#define APPMAX 5
+#define APPCOUNT 6
+#define APPIDS 7
+
+#endif /* _MIBGROUP_APP_H */
Index: net-snmp-5.7.2/agent/mibgroup/velocity/velocity_swrun.c
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/agent/mibgroup/velocity/velocity_swrun.c
@@ -0,0 +1,1595 @@
+/*
+ * Velocity MIB - Running Software group implementation - velocity_swrun.c
+ * (also includes Running Software Performance group extensions to the
+ * standard host resources MIB)
+ */
+
+#include <net-snmp/net-snmp-config.h>
+#if HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <fcntl.h>
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <sys/param.h>
+#include <ctype.h>
+#if HAVE_SYS_PSTAT_H
+#include <sys/pstat.h>
+#endif
+#if HAVE_SYS_USER_H
+#ifdef solaris2
+#define _KMEMUSER
+#endif
+#include <sys/user.h>
+#endif
+#if HAVE_SYS_PROC_H
+#include <sys/proc.h>
+#endif
+#if HAVE_KVM_H
+#include <kvm.h>
+#endif
+#if HAVE_SYS_SYSCTL_H
+#include <sys/sysctl.h>
+#endif
+#if HAVE_DIRENT_H && !defined(cygwin)
+#include <dirent.h>
+#else
+# define dirent direct
+# if HAVE_SYS_NDIR_H
+# include <sys/ndir.h>
+# endif
+# if HAVE_SYS_DIR_H
+# include <sys/dir.h>
+# endif
+# if HAVE_NDIR_H
+# include <ndir.h>
+# endif
+#endif
+#ifdef cygwin
+#include <windows.h>
+#include <sys/cygwin.h>
+#include <tlhelp32.h>
+#include <psapi.h>
+#endif
+
+#if _SLASH_PROC_METHOD_
+#include <procfs.h>
+#endif
+
+#if HAVE_STRING_H
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+
+#include <stdio.h>
+
+#include <pwd.h>
+#include <grp.h>
+#include <net-snmp/output_api.h>
+#include "host_res.h"
+#include "velocity_swrun.h"
+#include <net-snmp/agent/auto_nlist.h>
+#include "kernel.h"
+#if solaris2
+#include "kernel_sunos5.h"
+#endif
+
+ /*********************
+ *
+ * Initialisation & common implementation functions
+ *
+ *********************/
+void Init_VELOCITY_SWRun(void);
+int Get_Next_VELOCITY_SWRun(void);
+void End_VELOCITY_SWRun(void);
+int header_velocityswrun(struct variable *, oid *, size_t *, int,
+ size_t *, WriteMethod **);
+int header_velocityswrunEntry(struct variable *, oid *, size_t *,
+ int, size_t *, WriteMethod **);
+
+#ifdef dynix
+pid_t nextproc;
+static prpsinfo_t lowpsinfo, mypsinfo;
+#endif
+#ifdef cygwin
+static struct external_pinfo *curproc;
+static struct external_pinfo lowproc;
+#elif !defined(linux)
+static int LowProcIndex;
+#endif
+#if defined(hpux10) || defined(hpux11)
+struct pst_status *proc_table;
+struct pst_dynamic pst_dyn;
+#elif HAVE_KVM_GETPROCS
+struct kinfo_proc *proc_table;
+#elif defined(solaris2)
+int *proc_table;
+#else
+struct proc *proc_table;
+#endif
+#ifndef dynix
+int current_proc_entry;
+#endif
+
+
+#define VELOCITYSWRUN_OSINDEX 1
+
+#define VELOCITYSWRUN_INDEX 2
+#define VELOCITYSWRUN_NAME 3
+#define VELOCITYSWRUN_ID 4
+#define VELOCITYSWRUN_PATH 5
+#define VELOCITYSWRUN_PARAMS 6
+#define VELOCITYSWRUN_TYPE 7
+#define VELOCITYSWRUN_STATUS 8
+#define VELOCITYSWRUN_PPID 9
+#define VELOCITYSWRUN_PGRP 10
+
+#define VELOCITYSWRUNPERF_CPU_USER 11
+#define VELOCITYSWRUNPERF_CPU_SYS 12
+#define VELOCITYSWRUNPERF_MEM 13
+#define VELOCITYSWRUNPERF_CPU_CUMM_USER 14
+#define VELOCITYSWRUNPERF_CPU_CUMM_SYS 15
+#define VELOCITYSWRUNPERF_MIN_FAULT 16
+#define VELOCITYSWRUNPERF_MAJ_FAULT 17
+#define VELOCITYSWRUNPERF_MIN_FAULT_CUMM 18
+#define VELOCITYSWRUNPERF_MAJ_FAULT_CUMM 19
+#define VELOCITYSWRUNPERF_RSS 20
+#define VELOCITYSWRUNPERF_PRIO 21
+#define VELOCITYSWRUNPERF_ALL 22
+#define VELOCITYSWRUNPERF_UID 23
+#define VELOCITYSWRUNPERF_UNAME 24
+
+struct variable4 velocityswrun_variables[] = {
+ {VELOCITYSWRUN_OSINDEX, ASN_INTEGER, RONLY, var_velocityswrun, 1, {1}},
+ {VELOCITYSWRUN_INDEX, ASN_INTEGER, RONLY, var_velocityswrun, 3, {2, 1, 1}},
+ {VELOCITYSWRUN_NAME, ASN_OCTET_STR, RONLY, var_velocityswrun, 3, {2, 1, 2}},
+ {VELOCITYSWRUN_ID, ASN_OBJECT_ID, RONLY, var_velocityswrun, 3, {2, 1, 3}},
+ {VELOCITYSWRUN_PATH, ASN_OCTET_STR, RONLY, var_velocityswrun, 3, {2, 1, 4}},
+ {VELOCITYSWRUN_PARAMS, ASN_OCTET_STR, RONLY, var_velocityswrun, 3, {2, 1, 5}},
+ {VELOCITYSWRUN_TYPE, ASN_INTEGER, RONLY, var_velocityswrun, 3, {2, 1, 6}},
+ {VELOCITYSWRUN_STATUS, ASN_INTEGER, RONLY, var_velocityswrun, 3, {2, 1, 7}},
+ {VELOCITYSWRUN_PPID, ASN_INTEGER, RONLY, var_velocityswrun, 3, {2, 1, 8}},
+ {VELOCITYSWRUN_PGRP, ASN_INTEGER, RONLY, var_velocityswrun, 3, {2, 1, 9}}
+};
+
+struct variable4 velocityswrunperf_variables[] = {
+ {VELOCITYSWRUNPERF_CPU_USER, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 1}},
+ {VELOCITYSWRUNPERF_CPU_SYS, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 2}},
+ {VELOCITYSWRUNPERF_MEM, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 3}},
+ {VELOCITYSWRUNPERF_CPU_CUMM_USER, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 4}},
+ {VELOCITYSWRUNPERF_CPU_CUMM_SYS, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 5}},
+ {VELOCITYSWRUNPERF_MIN_FAULT, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 6}},
+ {VELOCITYSWRUNPERF_MAJ_FAULT, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 7}},
+ {VELOCITYSWRUNPERF_MIN_FAULT_CUMM, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 8}},
+ {VELOCITYSWRUNPERF_MAJ_FAULT_CUMM, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 9}},
+ {VELOCITYSWRUNPERF_RSS, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 10}},
+ {VELOCITYSWRUNPERF_PRIO, ASN_INTEGER, RONLY, var_velocityswrun, 3, {1, 1, 11}},
+ {VELOCITYSWRUNPERF_ALL, ASN_OCTET_STR, RONLY, var_velocityswrun, 3, {1, 1, 12}},
+ {VELOCITYSWRUNPERF_UID, ASN_OCTET_STR, RONLY, var_velocityswrun, 3, {1, 1, 13}},
+ {VELOCITYSWRUNPERF_UNAME, ASN_OCTET_STR, RONLY, var_velocityswrun, 3, {1, 1, 14}}
+};
+
+oid velocityswrun_variables_oid[] = { 1, 3, 6, 1, 4, 1, 15601, 4 };
+oid velocityswrunperf_variables_oid[] = { 1, 3, 6, 1, 4, 1, 15601, 5 };
+
+#ifdef cygwin
+
+/*
+ * a lot of this is "stolen" from cygwin ps.cc
+ */
+
+typedef BOOL(WINAPI * ENUMPROCESSMODULES) (HANDLE hProcess,
+ HMODULE * lphModule,
+ DWORD cb,
+ LPDWORD lpcbNeeded);
+
+typedef DWORD(WINAPI * GETMODULEFILENAME) (HANDLE hProcess,
+ HMODULE hModule,
+ LPTSTR lpstrFIleName,
+ DWORD nSize);
+
+typedef DWORD(WINAPI * GETPROCESSMEMORYINFO) (HANDLE hProcess,
+ PPROCESS_MEMORY_COUNTERS
+ pmc, DWORD nSize);
+
+typedef HANDLE(WINAPI * CREATESNAPSHOT) (DWORD dwFlags,
+ DWORD th32ProcessID);
+
+typedef BOOL(WINAPI * PROCESSWALK) (HANDLE hSnapshot,
+ LPPROCESSENTRY32 lppe);
+
+ENUMPROCESSMODULES myEnumProcessModules;
+GETMODULEFILENAME myGetModuleFileNameEx;
+CREATESNAPSHOT myCreateToolhelp32Snapshot;
+PROCESSWALK myProcess32First;
+PROCESSWALK myProcess32Next;
+GETPROCESSMEMORYINFO myGetProcessMemoryInfo = NULL;
+cygwin_getinfo_types query = CW_GETPINFO;
+
+static BOOL WINAPI
+dummyprocessmodules(HANDLE hProcess,
+ HMODULE * lphModule, DWORD cb, LPDWORD lpcbNeeded)
+{
+ lphModule[0] = (HMODULE) * lpcbNeeded;
+ *lpcbNeeded = 1;
+ return 1;
+}
+
+static DWORD WINAPI
+GetModuleFileNameEx95(HANDLE hProcess,
+ HMODULE hModule, LPTSTR lpstrFileName, DWORD n)
+{
+ HANDLE h;
+ DWORD pid = (DWORD) hModule;
+ PROCESSENTRY32 proc;
+
+ h = myCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+ if (!h)
+ return 0;
+ proc.dwSize = sizeof(proc);
+ if (myProcess32First(h, &proc))
+ do
+ if (proc.th32ProcessID == pid) {
+ CloseHandle(h);
+ strcpy(lpstrFileName, proc.szExeFile);
+ return 1;
+ }
+ while (myProcess32Next(h, &proc));
+ CloseHandle(h);
+ return 0;
+}
+
+#define FACTOR (0x19db1ded53ea710LL)
+#define NSPERSEC 10000000LL
+#define NSPERMSEC 10000LL
+
+static time_t __stdcall
+to_time_t(PFILETIME ptr)
+{
+ long rem;
+ long long x =
+ ((long long) ptr->dwHighDateTime << 32) +
+ ((unsigned) ptr->dwLowDateTime);
+ x -= FACTOR;
+ rem = x % NSPERSEC;
+ rem += NSPERSEC / 2;
+ x /= NSPERSEC;
+ x += rem / NSPERSEC;
+ return x;
+}
+
+static long
+to_msec(PFILETIME ptr)
+{
+ long long x =
+ ((long long) ptr->dwHighDateTime << 32) +
+ (unsigned) ptr->dwLowDateTime;
+ x /= NSPERMSEC;
+ return x;
+}
+
+#endif /* cygwin */
+
+
+void
+init_velocity_swrun(void)
+{
+#ifdef cygwin
+ OSVERSIONINFO ver;
+ HMODULE h;
+
+ memset(&ver, 0, sizeof ver);
+ ver.dwOSVersionInfoSize = sizeof ver;
+ GetVersionEx(&ver);
+
+ if (ver.dwPlatformId == VER_PLATFORM_WIN32_NT) {
+ h = LoadLibrary("psapi.dll");
+ if (h) {
+ myEnumProcessModules =
+ (ENUMPROCESSMODULES) GetProcAddress(h,
+ "EnumProcessModules");
+ myGetModuleFileNameEx =
+ (GETMODULEFILENAME) GetProcAddress(h,
+ "GetModuleFileNameExA");
+ myGetProcessMemoryInfo =
+ (GETPROCESSMEMORYINFO) GetProcAddress(h,
+ "GetProcessMemoryInfo");
+ if (myEnumProcessModules && myGetModuleFileNameEx)
+ query = CW_GETPINFO_FULL;
+ else
+ snmp_log(LOG_ERR, "velocity_swrun failed NT init\n");
+ } else
+ snmp_log(LOG_ERR, "velocity_swrun failed to load psapi.dll\n");
+ } else {
+ h = GetModuleHandle("KERNEL32.DLL");
+ myCreateToolhelp32Snapshot =
+ (CREATESNAPSHOT) GetProcAddress(h, "CreateToolhelp32Snapshot");
+ myProcess32First =
+ (PROCESSWALK) GetProcAddress(h, "Process32First");
+ myProcess32Next = (PROCESSWALK) GetProcAddress(h, "Process32Next");
+ myEnumProcessModules = dummyprocessmodules;
+ myGetModuleFileNameEx = GetModuleFileNameEx95;
+ if (myCreateToolhelp32Snapshot && myProcess32First
+ && myProcess32Next)
+#if 0
+ /*
+ * This doesn't work after all on Win98 SE
+ */
+ query = CW_GETPINFO_FULL;
+#else
+ query = CW_GETPINFO;
+#endif
+ else
+ snmp_log(LOG_ERR, "velocity_swrun failed non-NT init\n");
+ }
+#endif /* cygwin */
+#ifdef PROC_SYMBOL
+ auto_nlist(PROC_SYMBOL, 0, 0);
+#endif
+#ifdef NPROC_SYMBOL
+ auto_nlist(NPROC_SYMBOL, 0, 0);
+#endif
+
+ proc_table = 0;
+
+ REGISTER_MIB("velocity/velocity_swrun", velocityswrun_variables, variable4,
+ velocityswrun_variables_oid);
+ REGISTER_MIB("velocity/velocity_swrun", velocityswrunperf_variables, variable4,
+ velocityswrunperf_variables_oid);
+}
+
+/*
+ * header_velocityswrun(...
+ * 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_velocityswrun(struct variable *vp,
+ oid * name,
+ size_t * length,
+ int exact, size_t * var_len, WriteMethod ** write_method)
+{
+#define VELOCITYSWRUN_NAME_LENGTH 9
+ oid newname[MAX_OID_LEN];
+ int result;
+
+ DEBUGMSGTL(("velocity/velocity_swrun", "var_velocityswrun: \n"));
+ DEBUGMSGOID(("velocity/velocity_swrun", name, *length));
+ DEBUGMSG(("velocity/velocity_swrun", " %d\n", exact));
+
+ memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
+ newname[VELOCITYSWRUN_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 = 0;
+ *var_len = sizeof(long); /* default to 'long' results */
+ return (MATCH_SUCCEEDED);
+}
+
+int
+header_velocityswrunEntry(struct variable *vp,
+ oid * name,
+ size_t * length,
+ int exact,
+ size_t * var_len, WriteMethod ** write_method)
+{
+#define VELOCITYSWRUN_ENTRY_NAME_LENGTH 11
+ oid newname[MAX_OID_LEN];
+ int pid, LowPid = -1;
+ int result;
+
+ DEBUGMSGTL(("velocity/velocity_swrun", "var_velocityswrunEntry: \n"));
+ DEBUGMSGOID(("velocity/velocity_swrun", name, *length));
+ DEBUGMSG(("velocity/velocity_swrun", " %d\n", exact));
+
+ memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
+
+ /*
+ * Find the "next" running process
+ */
+ Init_VELOCITY_SWRun();
+ for (;;) {
+ pid = Get_Next_VELOCITY_SWRun();
+#ifndef linux
+#ifndef dynix
+ DEBUGMSG(("velocity/velocity_swrun",
+ "(index %d (entry #%d) ....", pid, current_proc_entry));
+#else
+ DEBUGMSG(("velocity/velocity_swrun", "pid %d; nextproc %d ....\n", pid,
+ nextproc));
+#endif
+#endif
+ if (pid == -1)
+ break;
+ newname[VELOCITYSWRUN_ENTRY_NAME_LENGTH] = pid;
+ DEBUGMSGOID(("velocity/velocity_swrun", newname, *length));
+ DEBUGMSG(("velocity/velocity_swrun", "newname\n"));
+ result = snmp_oid_compare(name, *length, newname, vp->namelen + 1);
+ if (exact && (result == 0)) {
+ LowPid = pid;
+#ifdef cygwin
+ lowproc = *curproc;
+#elif dynix
+ memcpy(&lowpsinfo, &mypsinfo, sizeof(prpsinfo_t));
+#elif !defined(linux)
+ LowProcIndex = current_proc_entry - 1;
+#endif
+ DEBUGMSGTL(("velocity/velocity_swrun", " saved\n"));
+ /*
+ * Save process status information
+ */
+ break;
+ }
+ if ((!exact && (result < 0)) && (LowPid == -1 || pid < LowPid)) {
+ LowPid = pid;
+#ifdef cygwin
+ lowproc = *curproc;
+#elif !defined(linux)
+ LowProcIndex = current_proc_entry - 1;
+#endif
+ /*
+ * Save process status information
+ */
+ DEBUGMSG(("velocity/velocity_swrun", " saved"));
+ }
+ DEBUGMSG(("velocity/velocity_swrun", "\n"));
+ }
+ End_VELOCITY_SWRun();
+
+ if (LowPid == -1) {
+ DEBUGMSGTL(("velocity/velocity_swrun", "... index out of range\n"));
+ return (MATCH_FAILED);
+ }
+
+ newname[VELOCITYSWRUN_ENTRY_NAME_LENGTH] = LowPid;
+ memcpy((char *) name, (char *) newname,
+ (vp->namelen + 1) * sizeof(oid));
+ *length = vp->namelen + 1;
+ *write_method = 0;
+ *var_len = sizeof(long); /* default to 'long' results */
+
+ DEBUGMSGTL(("velocity/velocity_swrun", "... get process stats\n"));
+ DEBUGMSGOID(("velocity/velocity_swrun", name, *length));
+ DEBUGMSG(("velocity/velocity_swrun", "\n"));
+ return LowPid;
+}
+
+ /*********************
+ *
+ * System specific implementation functions
+ *
+ *********************/
+
+
+u_char *
+var_velocityswrun(struct variable * vp,
+ oid * name,
+ size_t * length,
+ int exact, size_t * var_len, WriteMethod ** write_method)
+{
+ int pid = 0;
+ static char string[256];
+#ifdef HAVE_SYS_PSTAT_H
+ struct pst_status proc_buf;
+#elif defined(solaris2)
+#if _SLASH_PROC_METHOD_
+ static psinfo_t psinfo;
+ static psinfo_t *proc_buf;
+ int procfd;
+ char procfn[sizeof "/proc/00000/psinfo"];
+#else
+ static struct proc *proc_buf;
+ char *cp1;
+#endif /* _SLASH_PROC_METHOD_ */
+ static time_t when = 0;
+ time_t now;
+ static int oldpid = -1;
+#endif
+#if HAVE_KVM_GETPROCS
+ char **argv;
+#endif
+#ifdef linux
+ FILE *fp;
+ int fd;
+ char buf[256];
+ char buff[1024];
+ char uid[33];
+ char gid[33];
+ char unknown[] = "unknown";
+ int bsize;
+ int i;
+ int uid1, uid2, uid3, uid4;
+ int gid1, gid2, gid3, gid4;
+ struct passwd* pwd;
+ struct group* grp;
+ char *username = NULL;
+ char *groupname = NULL;
+#endif
+ char *cp;
+
+ if (vp->magic == VELOCITYSWRUN_OSINDEX) {
+ if (header_velocityswrun(vp, name, length, exact, var_len, write_method)
+ == MATCH_FAILED)
+ return NULL;
+ } else {
+
+ pid =
+ header_velocityswrunEntry(vp, name, length, exact, var_len,
+ write_method);
+ if (pid == MATCH_FAILED)
+ return NULL;
+ }
+
+#ifdef HAVE_SYS_PSTAT_H
+ if (pstat_getproc(&proc_buf, sizeof(struct pst_status), 0, pid) == -1)
+ return NULL;
+#elif defined(solaris2)
+ time(&now);
+ if (pid == oldpid) {
+ if (now != when)
+ oldpid = -1;
+ }
+ if (oldpid != pid || proc_buf == NULL) {
+#if _SLASH_PROC_METHOD_
+ proc_buf = &psinfo;
+ sprintf(procfn, "/proc/%.5d/psinfo", pid);
+ if ((procfd = open(procfn, O_RDONLY)) != -1) {
+ if (read(procfd, proc_buf, sizeof(*proc_buf)) !=
+ sizeof(*proc_buf))
+ abort();
+ close(procfd);
+ } else
+ proc_buf = NULL;
+#else
+ if (kd == NULL)
+ return NULL;
+ if ((proc_buf = kvm_getproc(kd, pid)) == NULL)
+ return NULL;
+#endif
+ oldpid = pid;
+ when = now;
+ }
+#endif
+
+ switch (vp->magic) {
+ case VELOCITYSWRUN_OSINDEX:
+#if NO_DUMMY_VALUES
+ return NULL;
+#else
+ long_return = 1; /* Probably! */
+ return (u_char *) & long_return;
+#endif
+
+ case VELOCITYSWRUN_INDEX:
+ long_return = pid;
+ return (u_char *) & long_return;
+ case VELOCITYSWRUN_NAME:
+#ifdef HAVE_SYS_PSTAT_H
+ sprintf(string, "%s", proc_buf.pst_cmd);
+ cp = strchr(string, ' ');
+ if (cp != NULL)
+ *cp = '\0';
+#elif defined(dynix)
+ sprintf(string, "%s", lowpsinfo.pr_fname);
+ cp = strchr(string, ' ');
+ if (cp != NULL)
+ *cp = '\0';
+#elif defined(solaris2)
+#if _SLASH_PROC_METHOD_
+ if (proc_buf)
+ strcpy(string, proc_buf->pr_fname);
+ else
+ strcpy(string, "<exited>");
+#else
+ strcpy(string, proc_buf->p_user.u_comm);
+#endif
+#elif HAVE_KVM_GETPROCS
+ strcpy(string, proc_table[LowProcIndex].kp_proc.p_comm);
+#elif defined(linux)
+ sprintf(string, "/proc/%d/status", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp); /* Name: process name */
+ cp = buf;
+ while (*cp != ':')
+ ++cp;
+ ++cp;
+ while (isspace(*cp))
+ ++cp;
+ strcpy(string, cp);
+ fclose(fp);
+#elif defined(cygwin)
+ if (lowproc.process_state & (PID_ZOMBIE | PID_EXITED))
+ strcpy(string, "<defunct>");
+ else if (lowproc.ppid) {
+ cygwin_conv_to_posix_path(lowproc.progname, string);
+ cp = strrcvelocity(string, '/');
+ if (cp)
+ strcpy(string, cp + 1);
+ } else if (query == CW_GETPINFO_FULL) {
+ DWORD n = lowproc.dwProcessId & 0xffff;
+ HANDLE h =
+ OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
+ FALSE, n);
+
+ if (h) {
+ HMODULE hm[1000];
+ if (!myEnumProcessModules(h, hm, sizeof hm, &n)) {
+ snmp_log(LOG_DEBUG, "no module handle for %lu\n", n);
+ n = 0;
+ }
+ if (n
+ && myGetModuleFileNameEx(h, hm[0], string,
+ sizeof string)) {
+ cp = strrcvelocity(string, '\\');
+ if (cp)
+ strcpy(string, cp + 1);
+ } else
+ strcpy(string, "*** unknown");
+ CloseHandle(h);
+ } else {
+ snmp_log(LOG_INFO, "no process handle for %lu\n", n);
+ strcpy(string, "** unknown");
+ }
+ } else
+ strcpy(string, "* unknown");
+ cp = strchr(string, '\0') - 4;
+ if (cp > string && strcasecmp(cp, ".exe") == 0)
+ *cp = '\0';
+#else
+#if NO_DUMMY_VALUES
+ return NULL;
+#endif
+ sprintf(string, "process name");
+#endif
+ *var_len = strlen(string);
+ /*
+ * remove trailing newline
+ */
+ if (*var_len) {
+ cp = string + *var_len - 1;
+ if (*cp == '\n')
+ --(*var_len);
+ }
+ return (u_char *) string;
+ case VELOCITYSWRUN_ID:
+ *var_len = nullOidLen;
+ return (u_char *) nullOid;
+ case VELOCITYSWRUN_PATH:
+#ifdef HAVE_SYS_PSTAT_H
+ /*
+ * Path not available - use argv[0]
+ */
+ sprintf(string, "%s", proc_buf.pst_cmd);
+ cp = strchr(string, ' ');
+ if (cp != NULL)
+ *cp = '\0';
+#elif defined(dynix)
+ /*
+ * Path not available - use argv[0]
+ */
+ sprintf(string, "%s", lowpsinfo.pr_psargs);
+ cp = strchr(string, ' ');
+ if (cp != NULL)
+ *cp = '\0';
+#elif defined(solaris2)
+#ifdef _SLASH_PROC_METHOD_
+ if (proc_buf)
+ strcpy(string, proc_buf->pr_psargs);
+ else
+ sprintf(string, "<exited>");
+ cp = strchr(string, ' ');
+ if (cp)
+ *cp = 0;
+#else
+ cp = proc_buf->p_user.u_psargs;
+ cp1 = string;
+ while (*cp && *cp != ' ')
+ *cp1++ = *cp++;
+ *cp1 = 0;
+#endif
+#elif HAVE_KVM_GETPROCS
+ strcpy(string, proc_table[LowProcIndex].kp_proc.p_comm);
+#elif defined(linux)
+ sprintf(string, "/proc/%d/cmdline", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ if (fgets(buf, sizeof(buf) - 1, fp)) /* argv[0] '\0' argv[1] '\0' .... */
+ strcpy(string, buf);
+ else {
+ /*
+ * swapped out - no cmdline
+ */
+ fclose(fp);
+ sprintf(string, "/proc/%d/status", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp); /* Name: process name */
+ cp = strchr(buf, ':');
+ ++cp;
+ while (isspace(*cp))
+ ++cp;
+ strcpy(string, cp);
+ cp = strchr(string, '\n');
+ if (cp)
+ *cp = 0;
+ }
+ fclose(fp);
+#elif defined(cygwin)
+ if (lowproc.process_state & (PID_ZOMBIE | PID_EXITED))
+ strcpy(string, "<defunct>");
+ else if (lowproc.ppid)
+ cygwin_conv_to_posix_path(lowproc.progname, string);
+ else if (query == CW_GETPINFO_FULL) {
+ DWORD n = lowproc.dwProcessId & 0xFFFF;
+ HANDLE h =
+ OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
+ FALSE, n);
+ if (h) {
+ HMODULE hm[1000];
+ if (!myEnumProcessModules(h, hm, sizeof hm, &n))
+ n = 0;
+ if (!n
+ || !myGetModuleFileNameEx(h, hm[0], string,
+ sizeof string))
+ strcpy(string, "*** unknown");
+ CloseHandle(h);
+ } else
+ strcpy(string, "** unknown");
+ } else
+ strcpy(string, "* unknown");
+#else
+#if NO_DUMMY_VALUES
+ return NULL;
+#endif
+ sprintf(string, "/bin/wombat");
+#endif
+ *var_len = strlen(string);
+ return (u_char *) string;
+ case VELOCITYSWRUN_PARAMS:
+#ifdef HAVE_SYS_PSTAT_H
+ cp = strchr(proc_buf.pst_cmd, ' ');
+ if (cp != NULL) {
+ cp++;
+ sprintf(string, "%s", cp);
+ } else
+ string[0] = '\0';
+#elif defined(dynix)
+ cp = strchr(lowpsinfo.pr_psargs, ' ');
+ if (cp != NULL) {
+ cp++;
+ sprintf(string, "%s", cp);
+ } else
+ string[0] = '\0';
+#elif defined(solaris2)
+#ifdef _SLASH_PROC_METHOD_
+ if (proc_buf) {
+ cp = strchr(proc_buf->pr_psargs, ' ');
+ if (cp)
+ strcpy(string, cp + 1);
+ else
+ string[0] = 0;
+ } else
+ string[0] = 0;
+#else
+ cp = proc_buf->p_user.u_psargs;
+ while (*cp && *cp != ' ')
+ cp++;
+ if (*cp == ' ')
+ cp++;
+ strcpy(string, cp);
+#endif
+#elif HAVE_KVM_GETPROCS
+ string[0] = 0;
+ argv = kvm_getargv(kd, proc_table + LowProcIndex, sizeof(string));
+ if (argv)
+ argv++;
+ while (argv && *argv) {
+ if (string[0] != 0)
+ strcat(string, " ");
+ strcat(string, *argv);
+ argv++;
+ }
+#elif defined(linux)
+ sprintf(string, "/proc/%d/cmdline", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ memset(buf, 0, sizeof(buf));
+
+ /*
+ * argv[0] '\0' argv[1] '\0' ....
+ */
+ if (!fgets(buf, sizeof(buf) - 2, fp)) {
+ /*
+ * maybe be empty (even argv[0] is missing)
+ */
+ string[0] = '\0';
+ *var_len = 0;
+ fclose(fp);
+ return string;
+ }
+
+ /*
+ * Skip over argv[0]
+ */
+ cp = buf;
+ while (*cp)
+ ++cp;
+ ++cp;
+ /*
+ * Now join together separate arguments.
+ */
+ while (1) {
+ while (*cp)
+ ++cp;
+ if (*(cp + 1) == '\0')
+ break; /* '\0''\0' => End of command line */
+ *cp = ' ';
+ }
+
+ cp = buf;
+ while (*cp)
+ ++cp;
+ ++cp;
+ strcpy(string, cp);
+ fclose(fp);
+#elif defined(cygwin)
+ string[0] = 0;
+#else
+#if NO_DUMMY_VALUES
+ return NULL;
+#endif
+ sprintf(string, "-h -q -v");
+#endif
+ *var_len = strlen(string);
+ return (u_char *) string;
+ case VELOCITYSWRUNPERF_ALL:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ strcpy(string,buf);
+
+ fclose(fp);
+#endif
+ *var_len = strlen(string);
+ return (u_char *) string;
+ case VELOCITYSWRUNPERF_UID:
+#if defined(linux)
+ sprintf(string, "/proc/%d/status", pid);
+ DEBUGMSG(("velocity/velocity_swrun", "In UID string=%s\n",string));
+ if ((fd = open(string, O_RDONLY, 0)) == -1)
+ return NULL;
+ bsize = read(fd, buff, sizeof(buff));
+ buff[bsize-1] = 0;
+ DEBUGMSG(("velocity/velocity_swrun", "In UID buff=%s\n",buff));
+ cp = strstr(buff, "Uid:");
+ DEBUGMSG(("velocity/velocity_swrun", "In UID cp=%s\n",cp));
+ if (cp)
+ sscanf(cp, "%*s %s %*s %*s %*s %*s %s", uid, gid);
+ else {
+ return NULL;
+ }
+ strcpy(string,uid);
+ strcat(string," ");
+ strcat(string,gid);
+ DEBUGMSG(("velocity/velocity_swrun", "In UID end string=%s\n",string));
+ close(fd);
+#endif
+ *var_len = strlen(string);
+ return (u_char *) string;
+ case VELOCITYSWRUNPERF_UNAME:
+#if defined(linux)
+ sprintf(string, "/proc/%d/status", pid);
+ DEBUGMSG(("velocity/velocity_swrun", "UName string=%s\n",string));
+ if ((fd = open(string, O_RDONLY, 0)) == -1)
+ return NULL;
+ bsize = read(fd, buff, sizeof(buff));
+ buff[bsize-1] = 0;
+ DEBUGMSG(("velocity/velocity_swrun", "UName buff=%s\n",buff));
+ cp = strstr(buff, "Uid:");
+ DEBUGMSG(("velocity/velocity_swrun", "UName cp=%s\n",cp));
+ if (cp)
+ sscanf(cp, "%*s %d %*s %*s %*s %*s %d", &uid1, &gid1);
+ else {
+ return NULL;
+ }
+ DEBUGMSG(("velocity/velocity_swrun", "UName uid1=%d gid1=%d\n", uid1, gid1));
+ pwd = getpwuid(uid1);
+ if ( pwd == NULL )
+ username = unknown;
+ else username = pwd->pw_name;
+ grp = getgrgid(gid1);
+ if ( grp == NULL )
+ groupname = unknown;
+ else groupname = grp->gr_name;
+/* strcpy(string,username);
+ strcat(string," ");
+ strcat(string,groupname); */
+ sprintf(string,"%s %s %d %d", username, groupname, uid1, gid1);
+ DEBUGMSG(("velocity/velocity_swrun", "UName end string=%s\n",string));
+ close(fd);
+#endif
+ *var_len = strlen(string);
+ return (u_char *) string;
+ case VELOCITYSWRUN_TYPE:
+#ifdef PID_MAXSYS
+ if (pid < PID_MAXSYS)
+ long_return = 2; /* operatingSystem */
+ else
+#endif
+ long_return = 4; /* application */
+ return (u_char *) & long_return;
+ case VELOCITYSWRUN_STATUS:
+#if defined(cygwin)
+ if (lowproc.process_state & PID_STOPPED)
+ long_return = 3; /* notRunnable */
+ else if (lowproc.process_state & PID_ZOMBIE)
+ long_return = 4; /* invalid */
+ else
+ long_return = 1; /* running */
+#elif !defined(linux)
+#if defined(hpux10) || defined(hpux11)
+ switch (proc_table[LowProcIndex].pst_stat) {
+ case PS_STOP:
+ long_return = 3; /* notRunnable */
+ break;
+ case PS_SLEEP:
+ long_return = 2; /* runnable */
+ break;
+ case PS_RUN:
+ long_return = 1; /* running */
+ break;
+ case PS_ZOMBIE:
+ case PS_IDLE:
+ case PS_OTHER:
+ default:
+ long_return = 4; /* invalid */
+ break;
+ }
+#else
+#if HAVE_KVM_GETPROCS
+ switch (proc_table[LowProcIndex].kp_proc.p_stat) {
+#elif defined(dynix)
+ switch (lowpsinfo.pr_state) {
+#elif defined(solaris2)
+#if _SLASH_PROC_METHOD_
+ switch (proc_buf ? proc_buf->pr_lwp.pr_state : SIDL) {
+#else
+ switch (proc_buf->p_stat) {
+#endif
+#else
+ switch (proc_table[LowProcIndex].p_stat) {
+#endif
+ case SSTOP:
+ long_return = 3; /* notRunnable */
+ break;
+ case 0:
+#ifdef SSWAP
+ case SSWAP:
+#endif
+#ifdef SSLEEP
+ case SSLEEP:
+#endif
+#ifdef SWAIT
+ case SWAIT:
+#endif
+ long_return = 2; /* runnable */
+ break;
+#ifdef SACTIVE
+ case SACTIVE:
+#endif
+#ifdef SRUN
+ case SRUN:
+#endif
+#ifdef SONPROC
+ case SONPROC:
+#endif
+ long_return = 1; /* running */
+ break;
+ case SIDL:
+ case SZOMB:
+ default:
+ long_return = 4; /* invalid */
+ break;
+ }
+#endif
+#else
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) != NULL) {
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 2; ++i) { /* skip two fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ switch (*cp) {
+ case 'R':
+ long_return = 1; /* running */
+ break;
+ case 'S':
+ long_return = 2; /* runnable */
+ break;
+ case 'D':
+ case 'T':
+ long_return = 3; /* notRunnable */
+ break;
+ case 'Z':
+ default:
+ long_return = 4; /* invalid */
+ break;
+ }
+ fclose(fp);
+ } else
+ long_return = 4; /* invalid */
+#endif
+ return (u_char *) & long_return;
+
+ case VELOCITYSWRUN_PPID:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 3; ++i) { /* skip 3 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* Parent Process ID */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUN_PGRP:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 4; ++i) { /* skip 4 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* Process group ID */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_CPU_USER:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 13; ++i) { /* skip 13 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* utime */
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_CPU_SYS:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 14; ++i) { /* skip 14 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* stime */
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_CPU_CUMM_USER:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 15; ++i) { /* skip 15 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* cutime */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_CPU_CUMM_SYS:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 16; ++i) { /* skip 16 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* cstime */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_MIN_FAULT:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 9; ++i) { /* skip 9 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* minflt */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_MAJ_FAULT:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 11; ++i) { /* skip 11 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* majflt */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_MIN_FAULT_CUMM:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 10; ++i) { /* skip 10 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* cminflt */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_MAJ_FAULT_CUMM:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 12; ++i) { /* skip 12 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* cmajflt */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_RSS:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 23; ++i) { /* skip 23 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* rss */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_PRIO:
+#if defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 18; ++i) { /* skip 18 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+
+ long_return = atoi(cp); /* priority */
+
+ fclose(fp);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSWRUNPERF_MEM:
+#ifdef HAVE_SYS_PSTAT_H
+ long_return = (proc_buf.pst_rssize << PGSHIFT) / 1024;
+#elif defined(dynix)
+ long_return = (lowpsinfo.pr_rssize * MMU_PAGESIZE) / 1024;
+#elif defined(solaris2)
+#if _SLASH_PROC_METHOD_
+ long_return = proc_buf ? proc_buf->pr_rssize : 0;
+#else
+ long_return = proc_buf->p_swrss;
+#endif
+#elif HAVE_KVM_GETPROCS
+#if defined(freebsd3) && !defined(darwin)
+ long_return =
+ proc_table[LowProcIndex].kp_eproc.e_vm.vm_map.size / 1024;
+#else
+ long_return = proc_table[LowProcIndex].kp_eproc.e_vm.vm_tsize +
+ proc_table[LowProcIndex].kp_eproc.e_vm.vm_ssize +
+ proc_table[LowProcIndex].kp_eproc.e_vm.vm_dsize;
+ long_return = long_return * (getpagesize() / 1024);
+#endif
+#elif defined(linux)
+ sprintf(string, "/proc/%d/stat", pid);
+ if ((fp = fopen(string, "r")) == NULL)
+ return NULL;
+ fgets(buf, sizeof(buf), fp);
+ cp = buf;
+ for (i = 0; i < 22; ++i) { /* skip 22 fields */
+ while (*cp != ' ')
+ ++cp;
+ ++cp;
+ }
+ long_return = atoi(cp) / 1024; /* perfmem in K */
+ fclose(fp);
+#elif defined(cygwin)
+ {
+ DWORD n = lowproc.dwProcessId;
+ HANDLE h =
+ OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
+ FALSE, n);
+ PROCESS_MEMORY_COUNTERS pmc;
+
+ if (h) {
+ if (myGetProcessMemoryInfo
+ && myGetProcessMemoryInfo(h, &pmc, sizeof pmc))
+ long_return = pmc.WorkingSetSize / 1024;
+ else {
+ snmp_log(LOG_INFO, "no process times for %lu (%lu)\n",
+ lowproc.pid, n);
+ long_return = 0;
+ }
+ CloseHandle(h);
+ } else {
+ snmp_log(LOG_INFO, "no process handle for %lu (%lu)\n",
+ lowproc.pid, n);
+ long_return = 0;
+ }
+ }
+#else
+#if NO_DUMMY_VALUES
+ return NULL;
+#endif
+ long_return = 16 * 1024; /* XXX - 16M! */
+#endif
+ return (u_char *) & long_return;
+ default:
+ DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_velocityswrun\n",
+ vp->magic));
+ }
+ return NULL;
+}
+
+
+ /*********************
+ *
+ * Internal implementation functions
+ *
+ *********************/
+
+#if defined(linux)
+
+DIR *vsprocdir = NULL;
+struct dirent *procentry_p;
+
+void
+Init_VELOCITY_SWRun(void)
+{
+ if (vsprocdir != NULL)
+ closedir(vsprocdir);
+ vsprocdir = opendir("/proc");
+}
+
+int
+Get_Next_VELOCITY_SWRun(void)
+{
+ int pid;
+ procentry_p = readdir(vsprocdir);
+
+ if (procentry_p == NULL)
+ return -1;
+
+ pid = atoi(procentry_p->d_name);
+ if (pid == 0)
+ return (Get_Next_VELOCITY_SWRun());
+ return pid;
+}
+
+void
+End_VELOCITY_SWRun(void)
+{
+ if (vsprocdir)
+ closedir(vsprocdir);
+ vsprocdir = NULL;
+}
+
+#elif defined(cygwin)
+
+static pid_t curpid;
+
+void
+Init_VELOCITY_SWRun(void)
+{
+ cygwin_internal(CW_LOCK_PINFO, 1000);
+ curpid = 0;
+}
+
+int
+Get_Next_VELOCITY_SWRun(void)
+{
+ curproc =
+ (struct external_pinfo *) cygwin_internal(query,
+ curpid | CW_NEXTPID);
+ if (curproc)
+ curpid = curproc->pid;
+ else {
+ curpid = -1;
+ }
+ return curpid;
+}
+
+void
+End_VELOCITY_SWRun(void)
+{
+ cygwin_internal(CW_UNLOCK_PINFO);
+}
+
+#elif defined(dynix)
+
+void
+Init_VELOCITY_SWRun(void)
+{
+ nextproc = 0;
+}
+
+int
+Get_Next_VELOCITY_SWRun(void)
+{
+ getprpsinfo_t *select = 0;
+
+ DEBUGMSGTL(("velocity/velocity_swrun::GetNextVELOCITY_SWRun",
+ "nextproc == %d... &nextproc = %u\n", nextproc,
+ &nextproc));
+ if ((nextproc = getprpsinfo(nextproc, select, &mypsinfo)) < 0) {
+ return -1;
+ } else {
+ DEBUGMSGTL(("velocity/velocity_swrun::GetNextVELOCITY_SWRun",
+ "getprpsinfo returned %d\n", nextproc));
+ return mypsinfo.pr_pid;
+ }
+
+}
+
+void
+End_VELOCITY_SWRun(void)
+{
+ /*
+ * just a stub... because it's declared
+ */
+}
+
+#else /* linux */
+
+static int nproc;
+
+void
+Init_VELOCITY_SWRun(void)
+{
+ size_t bytes;
+ static time_t iwhen = 0;
+ time_t now;
+
+ time(&now);
+ if (now == iwhen) {
+ current_proc_entry = 0;
+ return;
+ }
+ iwhen = now;
+
+#if defined(hpux10) || defined(hpux11)
+ pstat_getdynamic(&pst_dyn, sizeof(struct pst_dynamic), 1, 0);
+ nproc = pst_dyn.psd_activeprocs;
+ bytes = nproc * sizeof(struct pst_status);
+ if ((proc_table =
+ (struct pst_status *) realloc(proc_table, bytes)) == NULL) {
+ current_proc_entry = nproc + 1;
+ return;
+ }
+ pstat_getproc(proc_table, sizeof(struct pst_status), nproc, 0);
+
+#elif defined(solaris2)
+ if (!getKstatInt("unix", "system_misc", "nproc", &nproc)) {
+ current_proc_entry = nproc + 1;
+ return;
+ }
+ bytes = nproc * sizeof(int);
+ if ((proc_table = (int *) realloc(proc_table, bytes)) == NULL) {
+ current_proc_entry = nproc + 1;
+ return;
+ }
+ {
+ DIR *f;
+ struct dirent *dp;
+#if _SLASH_PROC_METHOD_ == 0
+ if (kd == NULL) {
+ current_proc_entry = nproc + 1;
+ return;
+ }
+#endif
+ f = opendir("/proc");
+ current_proc_entry = 0;
+ while ((dp = readdir(f)) != NULL && current_proc_entry < nproc)
+ if (dp->d_name[0] != '.')
+ proc_table[current_proc_entry++] = atoi(dp->d_name);
+ closedir(f);
+ }
+#elif HAVE_KVM_GETPROCS
+ {
+ if (kd == NULL) {
+ nproc = 0;
+ return;
+ }
+ proc_table = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc);
+ }
+#else
+
+ current_proc_entry = 1;
+#ifndef bsdi2
+ nproc = 0;
+
+ if (auto_nlist(NPROC_SYMBOL, (char *) &nproc, sizeof(int)) == 0) {
+ snmp_log_perror("Init_VELOCITY_SWRun-auto_nlist NPROC");
+ return;
+ }
+#endif
+ bytes = nproc * sizeof(struct proc);
+
+ if (proc_table)
+ free((char *) proc_table);
+ if ((proc_table = (struct proc *) malloc(bytes)) == NULL) {
+ nproc = 0;
+ snmp_log_perror("Init_VELOCITY_SWRun-malloc");
+ return;
+ }
+
+ {
+ int proc_table_base;
+ if (auto_nlist
+ (PROC_SYMBOL, (char *) &proc_table_base,
+ sizeof(proc_table_base)) == 0) {
+ nproc = 0;
+ snmp_log_perror("Init_VELOCITY_SWRun-auto_nlist PROC");
+ return;
+ }
+ if (klookup(proc_table_base, (char *) proc_table, bytes) == 0) {
+ nproc = 0;
+ snmp_log_perror("Init_VELOCITY_SWRun-klookup");
+ return;
+ }
+ }
+#endif
+ current_proc_entry = 0;
+}
+
+int
+Get_Next_VELOCITY_SWRun(void)
+{
+ while (current_proc_entry < nproc) {
+#if defined(hpux10) || defined(hpux11)
+ return proc_table[current_proc_entry++].pst_pid;
+#elif defined(solaris2)
+ return proc_table[current_proc_entry++];
+#elif HAVE_KVM_GETPROCS
+ if (proc_table[current_proc_entry].kp_proc.p_stat != 0)
+ return proc_table[current_proc_entry++].kp_proc.p_pid;
+#else
+ if (proc_table[current_proc_entry].p_stat != 0)
+ return proc_table[current_proc_entry++].p_pid;
+ else
+ ++current_proc_entry;
+#endif
+
+ }
+ return -1;
+}
+
+void
+End_VELOCITY_SWRun(void)
+{
+ current_proc_entry = nproc + 1;
+}
+#endif
+
+int
+vscount_processes(void)
+{
+#if !(defined(linux) || defined(cygwin)) || defined(hpux10) || defined(hpux11) || defined(solaris2) || HAVE_KVM_GETPROCS
+ int i;
+#endif
+ int total = 0;
+
+ Init_VELOCITY_SWRun();
+#if defined(hpux10) || defined(hpux11) || HAVE_KVM_GETPROCS || defined(solaris2)
+ total = nproc;
+#else
+#if !defined(linux) && !defined(cygwin) && !defined(dynix)
+ for (i = 0; i < nproc; ++i) {
+ if (proc_table[i].p_stat != 0)
+#else
+ while (Get_Next_VELOCITY_SWRun() != -1) {
+#endif
+ ++total;
+ }
+#endif /* !hpux10 && !hpux11 && !HAVE_KVM_GETPROCS && !solaris2 */
+ End_VELOCITY_SWRun();
+ return total;
+}
Index: net-snmp-5.7.2/agent/mibgroup/velocity/velocity_swrun.h
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/agent/mibgroup/velocity/velocity_swrun.h
@@ -0,0 +1,13 @@
+/*
+ * Velocity MIB - Running Software group interface - velocity_swrun.h
+ * (also includes Running Software Performance group extenstions to the
+ * standard host resources MIB)
+ */
+#ifndef _MIBGROUP_VELOCITYSWRUN_H
+#define _MIBGROUP_VELOCITYSWRUN_H
+
+extern void init_velocity_swrun(void);
+extern FindVarMethod var_velocityswrun;
+
+
+#endif /* _MIBGROUP_VELOCITYSWRUN_H */
Index: net-snmp-5.7.2/agent/mibgroup/velocity/velocity_system.c
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/agent/mibgroup/velocity/velocity_system.c
@@ -0,0 +1,403 @@
+/*
+ * Velocity MIB - system group implementation - velocity_system.c
+ *
+ */
+
+#include <net-snmp/net-snmp-config.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 "host.h"
+#include "host_res.h"
+#include "velocity_system.h"
+#include <net-snmp/agent/auto_nlist.h>
+
+#ifdef HAVE_SYS_PROC_H
+#include <sys/param.h>
+#include "sys/proc.h"
+#endif
+#if HAVE_UTMPX_H
+#include <utmpx.h>
+#else
+#include <utmp.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 velocitySystemMaxProcesses.
+ */
+#define NR_TASKS 0
+#endif
+#endif
+
+#if defined(hpux10) || defined(hpux11)
+#include <sys/pstat.h>
+#endif
+
+#ifdef HAVE_SYS_SYSCTL_H
+#include <sys/sysctl.h>
+#endif
+
+#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
+ *
+ *********************/
+
+static int get_load_dev(void);
+static int count_users(void);
+extern int count_processes(void);
+
+
+ /*********************
+ *
+ * Initialisation & common implementation functions
+ *
+ *********************/
+
+#define VELOCITYSYS_UPTIME 1
+#define VELOCITYSYS_DATE 2
+#define VELOCITYSYS_LOAD_DEV 3
+#define VELOCITYSYS_LOAD_PARAM 4
+#define VELOCITYSYS_USERS 5
+#define VELOCITYSYS_PROCS 6
+#define VELOCITYSYS_MAXPROCS 7
+#define VELOCITYSYS_PAGEIN 8
+#define VELOCITYSYS_PAGEOUT 9
+#define VELOCITYSYS_SWAPIN 10
+#define VELOCITYSYS_SWAPOUT 11
+#define VELOCITYSYS_INTR 12
+#define VELOCITYSYS_CTXT 13
+#define VELOCITYSYS_PROCTOTAL 14
+
+#define VELOCITY_TYPE_PAGE 101
+#define VELOCITY_TYPE_INTR 102
+#define VELOCITY_TYPE_CTXT 103
+#define VELOCITY_TYPE_SWAP 104
+#define VELOCITY_TYPE_PROCTOTAL 105
+
+#define VELOCITY_IN 200
+#define VELOCITY_OUT 201
+
+struct variable2 velocitysystem_variables[] = {
+ {VELOCITYSYS_UPTIME, ASN_TIMETICKS, RONLY, var_velocitysys, 1, {1}},
+ {VELOCITYSYS_DATE, ASN_OCTET_STR, RONLY, var_velocitysys, 1, {2}},
+ {VELOCITYSYS_LOAD_DEV, ASN_INTEGER, RONLY, var_velocitysys, 1, {3}},
+ {VELOCITYSYS_LOAD_PARAM, ASN_OCTET_STR, RONLY, var_velocitysys, 1, {4}},
+ {VELOCITYSYS_USERS, ASN_GAUGE, RONLY, var_velocitysys, 1, {5}},
+ {VELOCITYSYS_PROCS, ASN_GAUGE, RONLY, var_velocitysys, 1, {6}},
+ {VELOCITYSYS_MAXPROCS, ASN_INTEGER, RONLY, var_velocitysys, 1, {7}},
+ {VELOCITYSYS_PAGEIN, ASN_INTEGER, RONLY, var_velocitysys, 1, {8}},
+ {VELOCITYSYS_PAGEOUT, ASN_INTEGER, RONLY, var_velocitysys, 1, {9}},
+ {VELOCITYSYS_SWAPIN, ASN_INTEGER, RONLY, var_velocitysys, 1, {10}},
+ {VELOCITYSYS_SWAPOUT, ASN_INTEGER, RONLY, var_velocitysys, 1, {11}},
+ {VELOCITYSYS_INTR, ASN_INTEGER, RONLY, var_velocitysys, 1, {12}},
+ {VELOCITYSYS_CTXT, ASN_INTEGER, RONLY, var_velocitysys, 1, {13}},
+ {VELOCITYSYS_PROCTOTAL, ASN_INTEGER, RONLY, var_velocitysys, 1, {14}}
+};
+oid velocitysystem_variables_oid[] = { 1, 3, 6, 1, 4, 1, 15601, 1 };
+
+#ifdef linux
+int linux_stat(int, int);
+#endif
+
+
+
+void
+init_velocity_system(void)
+{
+#ifdef NPROC_SYMBOL
+ auto_nlist(NPROC_SYMBOL, 0, 0);
+#endif
+
+ REGISTER_MIB("velocity/velocity_system", velocitysystem_variables, variable2,
+ velocitysystem_variables_oid);
+}
+
+/*
+ * header_velocitysys(...
+ * 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_velocitysys(struct variable *vp,
+ oid * name,
+ size_t * length,
+ int exact, size_t * var_len, WriteMethod ** write_method)
+{
+#define VELOCITYSYS_NAME_LENGTH 9
+ oid newname[MAX_OID_LEN];
+ int result;
+
+ DEBUGMSGTL(("velocity/velocity_system", "var_velocitysys: "));
+ DEBUGMSGOID(("velocity/velocity_system", name, *length));
+ DEBUGMSG(("velocity/velocity_system", " %d\n", exact));
+
+ memcpy((char *) newname, (char *) vp->name, vp->namelen * sizeof(oid));
+ newname[VELOCITYSYS_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 = 0;
+ *var_len = sizeof(long); /* default to 'long' results */
+ return (MATCH_SUCCEEDED);
+}
+
+int
+linux_stat(int stat_type, int in_or_out)
+{
+ FILE *fp;
+ char buf[100];
+ int in = -1, out = -1;
+
+ if ((fp = fopen("/proc/stat", "r")) == NULL)
+ return -1;
+
+ while (fgets(buf, sizeof(buf), fp) != NULL) {
+ if ((!strncmp(buf, "page", 4) && stat_type == VELOCITY_TYPE_PAGE) ||
+ (!strncmp(buf, "intr", 4) && stat_type == VELOCITY_TYPE_INTR) ||
+ (!strncmp(buf, "ctxt", 4) && stat_type == VELOCITY_TYPE_CTXT) ||
+ (!strncmp(buf, "processes", 9) && stat_type == VELOCITY_TYPE_PROCTOTAL) ||
+ (!strncmp(buf, "swap", 4) && stat_type == VELOCITY_TYPE_SWAP)) {
+ sscanf(buf, "%*s %d %d", &in, &out);
+ DEBUGMSGTL(("string found", " %s type - %d\n", buf, stat_type));
+ break;
+ }
+ else {
+ DEBUGMSGTL(("string not found", " %s type - %d\n", buf, stat_type ));
+ }
+ }
+
+ fclose(fp);
+ return (in_or_out == VELOCITY_IN ? in : out);
+
+}
+
+
+
+ /*********************
+ *
+ * System specific implementation functions
+ *
+ *********************/
+
+u_char *
+var_velocitysys(struct variable * vp,
+ oid * name,
+ size_t * length,
+ int exact, size_t * var_len, WriteMethod ** write_method)
+{
+ static char string[100];
+ time_t now;
+#ifndef NR_TASKS
+ int nproc = 0;
+#endif
+#ifdef linux
+ FILE *fp;
+#endif
+#if CAN_USE_SYSCTL && defined(CTL_KERN) && defined(KERN_MAXPROC)
+ static int maxproc_mib[] = { CTL_KERN, KERN_MAXPROC };
+ int buf_size;
+#endif
+#if defined(hpux10) || defined(hpux11)
+ struct pst_static pst_buf;
+#endif
+
+ if (header_velocitysys(vp, name, length, exact, var_len, write_method) ==
+ MATCH_FAILED)
+ return NULL;
+
+ switch (vp->magic) {
+ case VELOCITYSYS_UPTIME:
+ long_return = get_uptime();
+ return (u_char *) & long_return;
+ case VELOCITYSYS_DATE:
+ (void *) time(&now);
+ return (u_char *) date_n_time(&now, var_len);
+ case VELOCITYSYS_LOAD_DEV:
+ long_return = get_load_dev();
+ return (u_char *) & long_return;
+ case VELOCITYSYS_LOAD_PARAM:
+#ifdef linux
+ fp = fopen("/proc/cmdline", "r");
+ fgets(string, sizeof(string), fp);
+ fclose(fp);
+#else
+#if NO_DUMMY_VALUES
+ return NULL;
+#endif
+ sprintf(string, "ask Dave"); /* XXX */
+#endif
+ *var_len = strlen(string);
+ return (u_char *) string;
+ case VELOCITYSYS_PAGEIN:
+ long_return = linux_stat(VELOCITY_TYPE_PAGE,VELOCITY_IN);
+ return (u_char *) & long_return;
+ case VELOCITYSYS_PAGEOUT:
+ long_return = linux_stat(VELOCITY_TYPE_PAGE,VELOCITY_OUT);
+ return (u_char *) & long_return;
+ case VELOCITYSYS_SWAPIN:
+ long_return = linux_stat(VELOCITY_TYPE_SWAP,VELOCITY_IN);
+ return (u_char *) & long_return;
+ case VELOCITYSYS_SWAPOUT:
+ long_return = linux_stat(VELOCITY_TYPE_SWAP,VELOCITY_OUT);
+ return (u_char *) & long_return;
+ case VELOCITYSYS_CTXT:
+ long_return = linux_stat(VELOCITY_TYPE_CTXT,VELOCITY_IN);
+ return (u_char *) & long_return;
+ case VELOCITYSYS_PROCTOTAL:
+ long_return = linux_stat(VELOCITY_TYPE_PROCTOTAL,VELOCITY_IN);
+ return (u_char *) & long_return;
+ case VELOCITYSYS_INTR:
+#ifdef linux
+ long_return = linux_stat(VELOCITY_TYPE_INTR,VELOCITY_IN);
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSYS_USERS:
+ long_return = count_users();
+ return (u_char *) & long_return;
+ case VELOCITYSYS_PROCS:
+#if USING_VELOCITY_VELOCITY_SWRUN_MODULE
+ long_return = count_processes();
+#else
+#if NO_DUMMY_VALUES
+ return NULL;
+#endif
+ long_return = 0;
+#endif
+ return (u_char *) & long_return;
+ case VELOCITYSYS_MAXPROCS:
+#if defined(NR_TASKS)
+ long_return = NR_TASKS; /* <linux/tasks.h> */
+#elif CAN_USE_SYSCTL && defined(CTL_KERN) && defined(KERN_MAXPROC)
+ 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(NPROC_SYMBOL)
+ auto_nlist(NPROC_SYMBOL, (char *) &nproc, sizeof(int));
+ long_return = nproc;
+#else
+#if NO_DUMMY_VALUES
+ return NULL;
+#endif
+ long_return = 0;
+#endif
+ return (u_char *) & long_return;
+ default:
+ DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_velocitysys\n",
+ vp->magic));
+ }
+ return NULL;
+}
+
+
+ /*********************
+ *
+ * Internal implementation functions
+ *
+ *********************/
+
+ /*
+ * Return the DeviceIndex corresponding
+ * to the boot device
+ */
+static int
+get_load_dev(void)
+{
+ return (HRDEV_DISK << HRDEV_TYPE_SHIFT); /* XXX */
+}
+
+static int
+count_users(void)
+{
+ int total = 0;
+#if HAVE_UTMPX_H
+#define setutent setutxent
+#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)
+#endif
+ ++total;
+ }
+ endutent();
+ 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 */
Index: net-snmp-5.7.2/agent/mibgroup/velocity/velocity_system.h
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/agent/mibgroup/velocity/velocity_system.h
@@ -0,0 +1,12 @@
+/*
+ * Velocity MIB - system group interface - velocity_system.h
+ *
+ */
+#ifndef _MIBGROUP_VELOCITYSYSTEM_H
+#define _MIBGROUP_VELOCITYSYSTEM_H
+
+extern void init_velocity_system(void);
+extern FindVarMethod var_velocitysys;
+
+
+#endif /* _MIBGROUP_VELOCITYSYSTEM_H */
Index: net-snmp-5.7.2/mibs/VELOCITY-MIB.txt
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/mibs/VELOCITY-MIB.txt
@@ -0,0 +1,671 @@
+VELOCITY-MIB DEFINITIONS ::= BEGIN
+
+IMPORTS
+MODULE-IDENTITY, OBJECT-TYPE, mib-2,
+Integer32, Counter32, Gauge32, TimeTicks, enterprises FROM SNMPv2-SMI
+
+TEXTUAL-CONVENTION, DisplayString,
+TruthValue, DateAndTime, AutonomousType FROM SNMPv2-TC
+
+MODULE-COMPLIANCE, OBJECT-GROUP FROM SNMPv2-CONF
+
+InterfaceIndexOrZero FROM IF-MIB;
+
+velocityMibModule MODULE-IDENTITY
+ LAST-UPDATED "200607310000Z" -- 31 July 2006
+ ORGANIZATION "Velocity Software Inc."
+ CONTACT-INFO
+ "Dennis Andrews
+ Postal: Velocity Software, Inc.
+ 106-D Castro St.
+ Mountain View, CA 94041
+ USA
+ Phone: 650-964-8867
+ Fax: 650-964-9012
+ Email: dennis@velocitysoftware.com"
+ DESCRIPTION
+ "This MIB is an extension of the host MIB. This MIB currently
+ only runs on linux. This is the original version."
+ ::= { velocityMIBAdminInfo 1 }
+
+velocity OBJECT IDENTIFIER ::= { enterprises 15601 }
+
+velocitySystem OBJECT IDENTIFIER ::= { velocity 1 }
+velocitySWRun OBJECT IDENTIFIER ::= { velocity 4 }
+velocitySWRunPerf OBJECT IDENTIFIER ::= { velocity 5 }
+velocityAppTable OBJECT IDENTIFIER ::= { velocity 6 }
+velocityMIBAdminInfo OBJECT IDENTIFIER ::= { velocity 7 }
+
+-- The Host Resources System Group
+
+velocitySystemUptime OBJECT-TYPE
+ SYNTAX TimeTicks
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The amount of time since this host was last
+ initialized. Note that this is different from
+ sysUpTime in the SNMPv2-MIB [RFC1907] because
+ sysUpTime is the uptime of the network management
+ portion of the system."
+ ::= { velocitySystem 1 }
+
+velocitySystemDate OBJECT-TYPE
+ SYNTAX DateAndTime
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "The host's notion of the local date and time of day."
+ ::= { velocitySystem 2 }
+
+velocitySystemInitialLoadDevice OBJECT-TYPE
+ SYNTAX Integer32 (1..2147483647)
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "The index of the velocityDeviceEntry for the device from
+ which this host is configured to load its initial
+ operating system configuration (i.e., which operating
+ system code and/or boot parameters).
+
+ Note that writing to this object just changes the
+ configuration that will be used the next time the
+ operating system is loaded and does not actually cause
+ the reload to occur."
+ ::= { velocitySystem 3 }
+
+velocitySystemInitialLoadParameters OBJECT-TYPE
+ SYNTAX InternationalDisplayString (SIZE (0..128))
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "This object contains the parameters (e.g. a pathname
+ and parameter) supplied to the load device when
+ requesting the initial operating system configuration
+ from that device.
+
+ Note that writing to this object just changes the
+ configuration that will be used the next time the
+ operating system is loaded and does not actually cause
+ the reload to occur."
+ ::= { velocitySystem 4 }
+
+velocitySystemNumUsers OBJECT-TYPE
+ SYNTAX Gauge32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of user sessions for which this host is
+ storing state information. A session is a collection
+ of processes requiring a single act of user
+ authentication and possibly subject to collective job
+ control."
+ ::= { velocitySystem 5 }
+
+velocitySystemProcesses OBJECT-TYPE
+ SYNTAX Gauge32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of process contexts currently loaded or
+ running on this system."
+ ::= { velocitySystem 6 }
+
+velocitySystemMaxProcesses OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The maximum number of process contexts this system
+ can support. If there is no fixed maximum, the value
+ should be zero. On systems that have a fixed maximum,
+ this object can help diagnose failures that occur when
+ this maximum is reached."
+ ::= { velocitySystem 7 }
+
+velocitySystemPageIn OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Total number of pages that the system paged in"
+ ::= { velocitySystem 8 }
+
+velocitySystemPageOut OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Total number of pages that the system paged out"
+ ::= { velocitySystem 9 }
+
+velocitySystemSwapIn OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Total number of swap pages that have been brought in"
+ ::= { velocitySystem 10 }
+
+velocitySystemSwapOut OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Total number of swap pages that have been swapped out"
+ ::= { velocitySystem 11 }
+
+velocitySystemInterupts OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Total number of interupts since system boot"
+ ::= { velocitySystem 12 }
+
+velocitySystemContext OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Total number of context switches the system had done."
+ ::= { velocitySystem 13 }
+
+velocitySystemProcessTotal OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Total number of processes the system has started since boot."
+ ::= { velocitySystem 14 }
+
+
+
+
+-- The Velocity Running Software Group
+--
+-- The velocitySWRunTable contains an entry for each distinct piece of
+-- software that is running or loaded into physical or virtual
+-- memory in preparation for running. This includes the velocity's
+-- operating system, device drivers, and applications.
+
+velocitySWOSIndex OBJECT-TYPE
+ SYNTAX Integer32 (1..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The value of the velocitySWRunIndex for the velocitySWRunEntry
+ that represents the primary operating system running
+ on this velocity. This object is useful for quickly and
+ uniquely identifying that primary operating system."
+ ::= { velocitySWRun 1 }
+
+velocitySWRunTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF VelocitySWRunEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The (conceptual) table of software running on the
+ velocity."
+ ::= { velocitySWRun 2 }
+
+velocitySWRunEntry OBJECT-TYPE
+ SYNTAX VelocitySWRunEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "A (conceptual) entry for one piece of software
+ running on the velocity Note that because the installed
+ software table only contains information for software
+ stored locally on this velocity, not every piece of
+ running software will be found in the installed
+ software table. This is true of software that was
+ loaded and run from a non-local source, such as a
+ network-mounted file system.
+
+ As an example of how objects in this table are named,
+ an instance of the velocitySWRunName object might be named
+ velocitySWRunName.1287"
+ INDEX { velocitySWRunIndex }
+ ::= { velocitySWRunTable 1 }
+
+VelocitySWRunEntry ::= SEQUENCE {
+ velocitySWRunIndex Integer32,
+ velocitySWRunName InternationalDisplayString,
+ velocitySWRunID ProductID,
+ velocitySWRunPath InternationalDisplayString,
+ velocitySWRunParameters InternationalDisplayString,
+ velocitySWRunType INTEGER,
+ velocitySWRunStatus INTEGER,
+ velocitySWRunPPID Integer32,
+ velocitySWRunPGRP Integer32
+ }
+
+velocitySWRunIndex OBJECT-TYPE
+ SYNTAX Integer32 (1..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "A unique value for each piece of software running on
+ the velocity. Wherever possible, this should be the
+ system's native, unique identification number."
+ ::= { velocitySWRunEntry 1 }
+
+velocitySWRunName OBJECT-TYPE
+ SYNTAX InternationalDisplayString (SIZE (0..64))
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "A textual description of this running piece of
+ software, including the manufacturer, revision, and
+ the name by which it is commonly known. If this
+ software was installed locally, this should be the
+ same string as used in the corresponding
+ velocitySWInstalledName."
+ ::= { velocitySWRunEntry 2 }
+
+velocitySWRunID OBJECT-TYPE
+ SYNTAX ProductID
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The product ID of this running piece of software."
+ ::= { velocitySWRunEntry 3 }
+
+velocitySWRunPath OBJECT-TYPE
+ SYNTAX InternationalDisplayString (SIZE(0..128))
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "A description of the location on long-term storage
+ (e.g. a disk drive) from which this software was
+ loaded."
+ ::= { velocitySWRunEntry 4 }
+
+velocitySWRunParameters OBJECT-TYPE
+ SYNTAX InternationalDisplayString (SIZE(0..128))
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "A description of the parameters supplied to this
+ software when it was initially loaded."
+ ::= { velocitySWRunEntry 5 }
+
+velocitySWRunType OBJECT-TYPE
+ SYNTAX INTEGER {
+ unknown(1),
+ operatingSystem(2),
+ deviceDriver(3),
+ application(4)
+ }
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The type of this software."
+ ::= { velocitySWRunEntry 6 }
+
+velocitySWRunStatus OBJECT-TYPE
+ SYNTAX INTEGER {
+ running(1),
+ runnable(2), -- waiting for resource
+ -- (i.e., CPU, memory, IO)
+ notRunnable(3), -- loaded but waiting for event
+ invalid(4) -- not loaded
+ }
+ MAX-ACCESS read-write
+ STATUS current
+ DESCRIPTION
+ "The status of this running piece of software.
+ Setting this value to invalid(4) shall cause this
+ software to stop running and to be unloaded. Sets to
+ other values are not valid."
+ ::= { velocitySWRunEntry 7 }
+
+velocitySWRunPPID OBJECT-TYPE
+ SYNTAX Integer32 (1..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The ID of the parent process."
+ ::= { velocitySWRunEntry 8 }
+
+velocitySWRunPGRP OBJECT-TYPE
+ SYNTAX Integer32 (1..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The ID of the process group that the process belongs to."
+ ::= { velocitySWRunEntry 9 }
+
+
+-- The Velocity Resources Running Software Performance Group
+--
+-- The velocitySWRunPerfTable contains an entry corresponding to
+-- each entry in the velocitySWRunTable.
+
+velocitySWRunPerfTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF VelocitySWRunPerfEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "The (conceptual) table of running software
+ performance metrics."
+ ::= { velocitySWRunPerf 1 }
+
+velocitySWRunPerfEntry OBJECT-TYPE
+ SYNTAX VelocitySWRunPerfEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "A (conceptual) entry containing software performance
+ metrics. As an example, an instance of the
+ velocitySWRunPerfCPU object might be named
+ velocitySWRunPerfCPU.1287"
+ AUGMENTS { velocitySWRunEntry } -- This table augments information in
+ -- the velocitySWRunTable.
+ ::= { velocitySWRunPerfTable 1 }
+
+VelocitySWRunPerfEntry ::= SEQUENCE {
+ velocitySWRunPerfCPUUser Integer32,
+ velocitySWRunPerfCPUSys Integer32,
+ velocitySWRunPerfMem KBytes,
+ velocitySWRunPerfCPUCummUser Integer32,
+ velocitySWRunPerfCPUCummSys Integer32,
+ velocitySWRunPerfMinFault Integer32,
+ velocitySWRunPerfMajFault Integer32,
+ velocitySWRunPerfMinFaultCumm Integer32,
+ velocitySWRunPerfMajFaultCumm Integer32,
+ velocitySWRunPerfRss Integer32,
+ velocitySWRunPerfPrio Integer32,
+ velocitySWRunPerfAll InternationalDisplayString,
+ velocitySWRunPerfUID InternationalDisplayString,
+ velocitySWRunPerfUName InternationalDisplayString
+}
+
+velocitySWRunPerfCPUUser OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of centi-seconds of the User's CPU
+ resources consumed by this process. Note that on a
+ multi-processor system, this value may increment by
+ more than one centi-second in one centi-second of real
+ (wall clock) time."
+ ::= { velocitySWRunPerfEntry 1 }
+
+velocitySWRunPerfCPUSys OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of centi-seconds of the system's CPU
+ resources consumed by this process. Note that on a
+ multi-processor system, this value may increment by
+ more than one centi-second in one centi-second of real
+ (wall clock) time."
+ ::= { velocitySWRunPerfEntry 2 }
+
+velocitySWRunPerfMem OBJECT-TYPE
+ SYNTAX KBytes
+ UNITS "KBytes"
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The total amount of real system memory allocated to
+ this process."
+ ::= { velocitySWRunPerfEntry 3 }
+
+velocitySWRunPerfCPUCummUser OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of cummulative centi-seconds of the total user's CPU
+ resources consumed by this process. Note that on a
+ multi-processor system, this value may increment by
+ more than one centi-second in one centi-second of real
+ (wall clock) time."
+ ::= { velocitySWRunPerfEntry 4 }
+
+velocitySWRunPerfCPUCummSys OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of cummulative centi-seconds of the total system's CPU
+ resources consumed by this process. Note that on a
+ multi-processor system, this value may increment by
+ more than one centi-second in one centi-second of real
+ (wall clock) time."
+ ::= { velocitySWRunPerfEntry 5 }
+
+velocitySWRunPerfMinFault OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of minor page faults. (Those that have not
+ required loading a page from disk.)"
+ ::= { velocitySWRunPerfEntry 6 }
+
+velocitySWRunPerfMajFault OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of major page faults. (Those that have
+ required loading a page from disk.)"
+ ::= { velocitySWRunPerfEntry 7 }
+
+velocitySWRunPerfMinFaultCumm OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of minor page faults for this process and its
+ children. (Those that have not required loading a page
+ from disk.)"
+ ::= { velocitySWRunPerfEntry 8 }
+
+velocitySWRunPerfMajFaultCumm OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of major page faults. for this process and its
+ children. (Those that have required loading a page from disk.)"
+ ::= { velocitySWRunPerfEntry 9 }
+
+velocitySWRunPerfRss OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of pages in real memory minus 3 for administrative
+ purposes. This is just the pages which count towards text,
+ data, or stack space. This does not include pages which
+ have not been demand-loaded in, or which are swapped out."
+ ::= { velocitySWRunPerfEntry 10 }
+
+velocitySWRunPerfPrio OBJECT-TYPE
+ SYNTAX Integer32 (0..2147483647)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The standard nice value, plus fifteen. The value is never
+ negative in the kernel."
+ ::= { velocitySWRunPerfEntry 11 }
+
+velocitySWRunPerfAll OBJECT-TYPE
+ SYNTAX InternationalDisplayString (SIZE (0..256))
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The complete information from the stat file for the given process"
+ ::= { velocitySWRunPerfEntry 12 }
+
+velocitySWRunPerfUID OBJECT-TYPE
+ SYNTAX InternationalDisplayString (SIZE(0..128))
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The owning user ID and group ID of this process."
+ ::= { velocitySWRunPerfEntry 13 }
+
+velocitySWRunPerfUName OBJECT-TYPE
+ SYNTAX InternationalDisplayString (SIZE(0..128))
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The name of the owning user ID and group of this process."
+ ::= { velocitySWRunPerfEntry 14 }
+
+velocityAppTable OBJECT-TYPE
+ SYNTAX SEQUENCE OF AppEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "A table containing a list of applications that are of special
+ interest. The process table is searched for the given string
+ that identifies the given process(s). Other than being able to
+ return the process ids of interest this is the same MIB is the
+ UCD-snmp proc MIB. "
+ ::= { velocity 6 }
+
+velocityAppEntry OBJECT-TYPE
+ SYNTAX velocityAppEntry
+ MAX-ACCESS not-accessible
+ STATUS current
+ DESCRIPTION
+ "An entry containing an application and its statistics."
+ INDEX { appIndex }
+ ::= { velocityAppTable 1 }
+
+velocityAppEntry ::= SEQUENCE {
+ velocityAppIndex Integer32,
+ velocityAppNames DisplayString,
+ velocityAppPid DisplayString,
+ velocityAppMin Integer32,
+ velocityAppMax Integer32,
+ velocityAppCount Integer32,
+ velocityAppIds DisplayString,
+ velocityAppErrorFlag Integer32,
+ velocityAppErrMessage DisplayString
+}
+
+velocityAppIndex OBJECT-TYPE
+ SYNTAX Integer32 (0..65535)
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "Reference Index for each observed application."
+ ::= { velocityAppEntry 1 }
+
+velocityAppNames OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The application name we're counting/checking on."
+ ::= { velocityAppEntry 2 }
+
+velocityAppPid OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The absolute location of the PID file for the application."
+ ::= { velocityAppEntry 3 }
+
+velocityAppMin OBJECT-TYPE
+ SYNTAX Integer32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The minimum number of processes for that applicationes that should be
+ running. An error flag is generated if the number of
+ running processes is < the minimum."
+ ::= { velocityAppEntry 4 }
+
+velocityAppMax OBJECT-TYPE
+ SYNTAX Integer32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The maximum number of processes for that application that should be
+ running. An error flag is generated if the number of
+ running processes is > the maximum."
+ ::= { velocityAppEntry 5 }
+
+velocityAppCount OBJECT-TYPE
+ SYNTAX Integer32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The number of current applications running with the name
+ in question."
+ ::= { velocityAppEntry 6 }
+
+velocityAppIds OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "The list of process Ids that match the Application name."
+ ::= { velocityAppEntry 7 }
+
+velocityAppErrorFlag OBJECT-TYPE
+ SYNTAX Integer32
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "A Error flag to indicate trouble with a application. It
+ goes to 1 if there is an error, 0 if no error."
+ ::= { velocityAppEntry 100 }
+
+velocityAppErrMessage OBJECT-TYPE
+ SYNTAX DisplayString
+ MAX-ACCESS read-only
+ STATUS current
+ DESCRIPTION
+ "An error message describing the problem (if one exists)."
+ ::= { velocityAppEntry 101 }
+
+velocityMIBCompliances OBJECT IDENTIFIER ::= { velocityMIBAdminInfo 2 }
+velocityMIBGroups OBJECT IDENTIFIER ::= { velocityMIBAdminInfo 3 }
+
+ velocitySystemGroup OBJECT-GROUP
+ OBJECTS {
+ velocitySystemUptime, velocitySystemDate,
+ velocitySystemInitialLoadDevice,
+ velocitySystemInitialLoadParameters,
+ velocitySystemNumUsers, velocitySystemProcesses,
+ velocitySystemMaxProcesses
+ }
+ STATUS current
+ DESCRIPTION
+ "The Velocity System Group."
+ ::= { velocityMIBGroups 1 }
+
+ velocitySWRunGroup OBJECT-GROUP
+ OBJECTS {
+ velocitySWOSIndex, velocitySWRunIndex, velocitySWRunName,
+ velocitySWRunID, velocitySWRunPath, velocitySWRunParameters,
+ velocitySWRunType, velocitySWRunStatus, velocitySWRunPPID,
+ velocitySWRunPGRP
+ }
+ STATUS current
+ DESCRIPTION
+ "The Velocity Resources Running Software Group."
+ ::= { velocityMIBGroups 4 }
+
+ velocitySWRunPerfGroup OBJECT-GROUP
+ OBJECTS { velocitySWRunPerfCPUUser, velocitySWRunPerfCPUSys, velocitySWRunPerfMem, velocitySWRunPerfCPUCummUser, velocitySWRunPerfCPUCummSys }
+ STATUS current
+ DESCRIPTION
+ "The Velocity Resources Running Software
+ Performance Group."
+ ::= { velocityMIBGroups 5 }
+
+END
Index: net-snmp-5.7.2/mibs/VELOCITY-TYPES.txt
===================================================================
--- /dev/null
+++ net-snmp-5.7.2/mibs/VELOCITY-TYPES.txt
@@ -0,0 +1,23 @@
+VELOCITY-TYPES DEFINITIONS ::= BEGIN
+
+IMPORTS
+ MODULE-IDENTITY, OBJECT-IDENTITY FROM SNMPv2-SMI
+
+velocityMibModule MODULE-IDENTITY
+ LAST-UPDATED "200607310000Z" -- 31 July 2006
+ ORGANIZATION "Velocity Software Inc."
+ CONTACT-INFO
+ "Dennis Andrews
+ Postal: Velocity Software, Inc.
+ 106-D Castro St.
+ Mountain View, CA 94041
+ USA
+ Phone: 650-964-8867
+ Fax: 650-964-9012
+ Email: dennis@velocitysoftware.com"
+ DESCRIPTION
+ "This MIB is an extension of the host MIB. This MIB currently
+ only runs on linux. This is the original version."
+ ::= { velocityMIBAdminInfo 4 }
+
+END
Reference in New Issue View Git Blame Copy Permalink