265 lines
6.3 KiB
C
265 lines
6.3 KiB
C
/***********************************************************************
|
|
Net-SNMP - Simple Network Management Protocol agent library.
|
|
***********************************************************************/
|
|
/** @file kernel.c
|
|
* Net-SNMP Kernel Data Access Library.
|
|
* Provides access to kernel virtual memory for systems that
|
|
* support it.
|
|
* @author See README file for a list of contributors
|
|
*/
|
|
/* Copyrights:
|
|
* Copyright holders are listed in README file.
|
|
* Redistribution and use in source and binary forms, with or
|
|
* without modification, are permitted. License terms are specified
|
|
* in COPYING file distributed with the Net-SNMP package.
|
|
*/
|
|
/***********************************************************************/
|
|
|
|
#include <net-snmp/net-snmp-config.h>
|
|
|
|
#include <sys/types.h>
|
|
#if HAVE_STDLIB_H
|
|
#include <stdlib.h>
|
|
#endif
|
|
#if HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#if HAVE_STRING_H
|
|
#include <string.h>
|
|
#endif
|
|
#if HAVE_FCNTL_H
|
|
#include <fcntl.h>
|
|
#endif
|
|
#if HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#if HAVE_KVM_H
|
|
#include <kvm.h>
|
|
#endif
|
|
|
|
#include <net-snmp/net-snmp-includes.h>
|
|
|
|
#include "kernel.h"
|
|
#include <net-snmp/agent/ds_agent.h>
|
|
|
|
#ifndef NULL
|
|
#define NULL 0
|
|
#endif
|
|
|
|
|
|
#if HAVE_KVM_H
|
|
kvm_t *kd = NULL;
|
|
|
|
/**
|
|
* Initialize the support for accessing kernel virtual memory.
|
|
*
|
|
* @return TRUE upon success; FALSE upon failure.
|
|
*/
|
|
int
|
|
init_kmem(const char *file)
|
|
{
|
|
int res = TRUE;
|
|
|
|
#if HAVE_KVM_OPENFILES
|
|
char err[4096];
|
|
|
|
kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, err);
|
|
if (!kd)
|
|
#ifdef KVM_NO_FILES
|
|
kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, err);
|
|
#else
|
|
kd = kvm_openfiles(NULL, "/dev/null", NULL, O_RDONLY, err);
|
|
#endif
|
|
if (!kd && !netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
|
|
NETSNMP_DS_AGENT_NO_ROOT_ACCESS)) {
|
|
snmp_log(LOG_CRIT, "init_kmem: kvm_openfiles failed: %s\n", err);
|
|
res = FALSE;
|
|
}
|
|
#else
|
|
kd = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL);
|
|
if (!kd && !netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
|
|
NETSNMP_DS_AGENT_NO_ROOT_ACCESS)) {
|
|
snmp_log(LOG_CRIT, "init_kmem: kvm_open failed: %s\n",
|
|
strerror(errno));
|
|
res = FALSE;
|
|
}
|
|
#endif /* HAVE_KVM_OPENFILES */
|
|
return res;
|
|
}
|
|
|
|
/** Reads kernel memory.
|
|
* Seeks to the specified location in kmem, then
|
|
* does a read of given amount ob bytes into target buffer.
|
|
*
|
|
* @param off The location to seek.
|
|
*
|
|
* @param target The target buffer to read into.
|
|
*
|
|
* @param siz Number of bytes to read.
|
|
*
|
|
* @return gives 1 on success and 0 on failure.
|
|
*/
|
|
int
|
|
klookup(unsigned long off, void *target, size_t siz)
|
|
{
|
|
int result;
|
|
|
|
if (kd == NULL)
|
|
return 0;
|
|
result = kvm_read(kd, off, target, siz);
|
|
if (result != siz) {
|
|
#if HAVE_KVM_OPENFILES
|
|
snmp_log(LOG_ERR, "kvm_read(*, %lx, %p, %x) = %d: %s\n", off,
|
|
target, (unsigned) siz, result, kvm_geterr(kd));
|
|
#else
|
|
snmp_log(LOG_ERR, "kvm_read(*, %lx, %p, %d) = %d: ", off, target,
|
|
(unsigned) siz, result);
|
|
snmp_log_perror("klookup");
|
|
#endif
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/** Closes the kernel memory support.
|
|
*/
|
|
void
|
|
free_kmem(void)
|
|
{
|
|
if (kd != NULL)
|
|
{
|
|
kvm_close(kd);
|
|
kd = NULL;
|
|
}
|
|
}
|
|
|
|
#else /* HAVE_KVM_H */
|
|
|
|
#ifdef HAVE_KMEM
|
|
|
|
static off_t klseek(off_t);
|
|
static int klread(char *, int);
|
|
int swap = -1, mem = -1, kmem = -1;
|
|
|
|
/**
|
|
* Initialize the support for accessing kernel virtual memory.
|
|
*
|
|
* @return TRUE upon success; FALSE upon failure.
|
|
*/
|
|
int
|
|
init_kmem(const char *file)
|
|
{
|
|
const int no_root_access = netsnmp_ds_get_boolean(NETSNMP_DS_APPLICATION_ID,
|
|
NETSNMP_DS_AGENT_NO_ROOT_ACCESS);
|
|
int res = TRUE;
|
|
|
|
kmem = open(file, O_RDONLY);
|
|
if (kmem < 0 && !no_root_access) {
|
|
snmp_log_perror(file);
|
|
res = FALSE;
|
|
}
|
|
if (kmem >= 0)
|
|
fcntl(kmem, F_SETFD, 1/*FD_CLOEXEC*/);
|
|
mem = open("/dev/mem", O_RDONLY);
|
|
if (mem < 0 && !no_root_access) {
|
|
snmp_log_perror("/dev/mem");
|
|
res = FALSE;
|
|
}
|
|
if (mem >= 0)
|
|
fcntl(mem, F_SETFD, 1/*FD_CLOEXEC*/);
|
|
#ifdef DMEM_LOC
|
|
swap = open(DMEM_LOC, O_RDONLY);
|
|
if (swap < 0 && !no_root_access) {
|
|
snmp_log_perror(DMEM_LOC);
|
|
res = FALSE;
|
|
}
|
|
if (swap >= 0)
|
|
fcntl(swap, F_SETFD, 1/*FD_CLOEXEC*/);
|
|
#endif
|
|
return res;
|
|
}
|
|
|
|
/** @private
|
|
* Seek into the kernel for a value.
|
|
*/
|
|
static off_t
|
|
klseek(off_t base)
|
|
{
|
|
return (lseek(kmem, (off_t) base, SEEK_SET));
|
|
}
|
|
|
|
/** @private
|
|
* Read from the kernel.
|
|
*/
|
|
static int
|
|
klread(char *buf, int buflen)
|
|
{
|
|
return (read(kmem, buf, buflen));
|
|
}
|
|
|
|
/** Reads kernel memory.
|
|
* Seeks to the specified location in kmem, then
|
|
* does a read of given amount ob bytes into target buffer.
|
|
*
|
|
* @param off The location to seek.
|
|
*
|
|
* @param target The target buffer to read into.
|
|
*
|
|
* @param siz Number of bytes to read.
|
|
*
|
|
* @return gives 1 on success and 0 on failure.
|
|
*/
|
|
int
|
|
klookup(unsigned long off, void *target, size_t siz)
|
|
{
|
|
long retsiz;
|
|
|
|
if (kmem < 0)
|
|
return 0;
|
|
|
|
if ((retsiz = klseek((off_t) off)) != off) {
|
|
snmp_log(LOG_ERR, "klookup(%lx, %p, %d): ", off, target, (int) siz);
|
|
snmp_log_perror("klseek");
|
|
return (0);
|
|
}
|
|
if ((retsiz = klread(target, siz)) != siz) {
|
|
if (snmp_get_do_debugging()) {
|
|
/*
|
|
* these happen too often on too many architectures to print them
|
|
* unless we're in debugging mode. People get very full log files.
|
|
*/
|
|
snmp_log(LOG_ERR, "klookup(%lx, %p, %d): ", off, target, (int) siz);
|
|
snmp_log_perror("klread");
|
|
}
|
|
return (0);
|
|
}
|
|
DEBUGMSGTL(("verbose:kernel:klookup", "klookup(%lx, %p, %d) succeeded",
|
|
off, target, (int) siz));
|
|
return (1);
|
|
}
|
|
|
|
/** Closes the kernel memory support.
|
|
*/
|
|
void
|
|
free_kmem(void)
|
|
{
|
|
if (swap >= 0) {
|
|
close(swap);
|
|
swap = -1;
|
|
}
|
|
if (mem >= 0) {
|
|
close(mem);
|
|
mem = -1;
|
|
}
|
|
if (kmem >= 0) {
|
|
close(kmem);
|
|
kmem = -1;
|
|
}
|
|
}
|
|
|
|
#endif /* HAVE_KMEM */
|
|
|
|
#endif /* HAVE_KVM_H */
|