/*
* Host Resources MIB - partition device group implementation - hr_partition.c
*
*/
/* Portions of this file are subject to the following copyright(s). See
* the Net-SNMP's COPYING file for more details and other copyrights
* that may apply:
*/
/*
* Portions of this file are copyrighted by:
* Copyright (C) 2007 Apple, Inc. All rights reserved.
* Use is subject to license terms specified in the COPYING file
* distributed with the Net-SNMP package.
*/
#include <net-snmp/net-snmp-config.h>
#include <fcntl.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <errno.h>
#include "host_res.h"
#include "hr_partition.h"
#include "hr_filesys.h"
#include "hr_disk.h"
#include <sys/stat.h>
#define HRP_MONOTONICALLY_INCREASING
/*********************
*
* Kernel & interface information,
* and internal forward declarations
*
*********************/
static int HRP_savedDiskIndex;
static int HRP_savedPartIndex;
static char HRP_savedName[1024];
#ifdef NETSNMP_CAN_GET_DISK_LABEL
static char HRP_savedLabel[1024];
#endif
#ifdef darwin
extern int
Get_HR_Disk_Label(char *string, size_t str_len, const char *devfull);
#endif
static int HRP_DiskIndex;
static void Save_HR_Partition(int, int);
/*********************
*
* Initialisation & common implementation functions
*
*********************/
static void Init_HR_Partition(void);
static int Get_Next_HR_Partition(void);
#define HRPART_INDEX 1
#define HRPART_LABEL 2
#define HRPART_ID 3
#define HRPART_SIZE 4
#define HRPART_FSIDX 5
struct variable4 hrpartition_variables[] = {
{HRPART_INDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrpartition, 2, {1, 1}},
{HRPART_LABEL, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_hrpartition, 2, {1, 2}},
{HRPART_ID, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_hrpartition, 2, {1, 3}},
{HRPART_SIZE, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrpartition, 2, {1, 4}},
{HRPART_FSIDX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_hrpartition, 2, {1, 5}}
};
oid hrpartition_variables_oid[] =
{ 1, 3, 6, 1, 2, 1, 25, 3, 7 };
void
init_hr_partition(void)
{
REGISTER_MIB("host/hr_partition", hrpartition_variables, variable4,
hrpartition_variables_oid);
}
/*
* header_hrpartition(...
* 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_hrpartition(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
#define HRPART_DISK_NAME_LENGTH 11
#define HRPART_ENTRY_NAME_LENGTH 12
oid newname[MAX_OID_LEN];
int part_idx, LowDiskIndex = -1, LowPartIndex = -1;
int result;
DEBUGMSGTL(("host/hr_partition", "var_hrpartition: "));
DEBUGMSGOID(("host/hr_partition", name, *length));
DEBUGMSG(("host/hr_partition", " %d\n", exact));
memcpy((char *) newname, (char *) vp->name,
(int) vp->namelen * sizeof(oid));
/*
* Find "next" partition entry
*/
Init_HR_Disk();
Init_HR_Partition();
/*
* Find the "next" disk and partition entries.
* If we're in the middle of the table, then there's
* no point in examining earlier disks, so set the
* starting disk to that of the variable being queried.
*
* If we've moved from one column of the table to another,
* then we need to start at the beginning again.
* (i.e. the 'compare' fails to match)
* Similarly if we're at the start of the table
* (i.e. *length is too short to be a full instance)
*/
if ((snmp_oid_compare(vp->name, vp->namelen, name, vp->namelen) == 0)
&& (*length > HRPART_DISK_NAME_LENGTH)) {
LowDiskIndex =
(name[HRPART_DISK_NAME_LENGTH] &
((1 << HRDEV_TYPE_SHIFT) - 1));
DEBUGMSGTL(("host/hr_partition", "... low index %d\n", LowDiskIndex));
while (HRP_DiskIndex < LowDiskIndex) {
Init_HR_Partition(); /* moves to next disk */
if (HRP_DiskIndex == -1)
return (MATCH_FAILED);
}
}
for (;;) {
part_idx = Get_Next_HR_Partition();
DEBUGMSGTL(("host/hr_partition", "... part index %d\n", part_idx));
if (part_idx == 0)
break;
newname[HRPART_DISK_NAME_LENGTH] =
(HRDEV_DISK << HRDEV_TYPE_SHIFT) + HRP_DiskIndex;
newname[HRPART_ENTRY_NAME_LENGTH] = part_idx;
result = snmp_oid_compare(name, *length, newname, vp->namelen + 2);
if (exact && (result == 0)) {
Save_HR_Partition(HRP_DiskIndex, part_idx);
LowDiskIndex = HRP_DiskIndex;
LowPartIndex = part_idx;
break;
}
if (!exact && (result < 0)) {
if (LowPartIndex == -1) {
Save_HR_Partition(HRP_DiskIndex, part_idx);
LowDiskIndex = HRP_DiskIndex;
LowPartIndex = part_idx;
} else if (LowDiskIndex < HRP_DiskIndex)
break;
else if (part_idx < LowPartIndex) {
Save_HR_Partition(HRP_DiskIndex, part_idx);
LowDiskIndex = HRP_DiskIndex;
LowPartIndex = part_idx;
}
#ifdef HRP_MONOTONICALLY_INCREASING
break;
#endif
}
}
if (LowPartIndex == -1) {
DEBUGMSGTL(("host/hr_partition", "... index out of range\n"));
return (MATCH_FAILED);
}
newname[HRPART_DISK_NAME_LENGTH] =
(HRDEV_DISK << HRDEV_TYPE_SHIFT) + LowDiskIndex;
newname[HRPART_ENTRY_NAME_LENGTH] = LowPartIndex;
memcpy((char *) name, (char *) newname,
((int) vp->namelen + 2) * sizeof(oid));
*length = vp->namelen + 2;
*write_method = (WriteMethod*)0;
*var_len = sizeof(long); /* default to 'long' results */
DEBUGMSGTL(("host/hr_partition", "... get partition stats "));
DEBUGMSGOID(("host/hr_partition", name, *length));
DEBUGMSG(("host/hr_partition", "\n"));
return LowPartIndex;
}
/*********************
*
* System specific implementation functions
*
*********************/
u_char *
var_hrpartition(struct variable * vp,
oid * name,
size_t * length,
int exact, size_t * var_len, WriteMethod ** write_method)
{
int part_idx;
static char string[1024];
struct stat stat_buf;
part_idx =
header_hrpartition(vp, name, length, exact, var_len, write_method);
if (part_idx == MATCH_FAILED)
return NULL;
if (stat(HRP_savedName, &stat_buf) == -1)
return NULL;
switch (vp->magic) {
case HRPART_INDEX:
long_return = part_idx;
return (u_char *) & long_return;
case HRPART_LABEL:
#ifdef NETSNMP_CAN_GET_DISK_LABEL
*var_len = strlen(HRP_savedLabel);
return (u_char *) HRP_savedLabel;
#else
*var_len = strlen(HRP_savedName);
return (u_char *) HRP_savedName;
#endif
case HRPART_ID: /* Use the device number */
sprintf(string, "0x%x", (int) stat_buf.st_rdev);
*var_len = strlen(string);
return (u_char *) string;
case HRPART_SIZE:
/*
* XXX - based on single partition assumption
*/
long_return = Get_FSSize(HRP_savedName);
return (u_char *) & long_return;
case HRPART_FSIDX:
long_return = Get_FSIndex(HRP_savedName);
return (u_char *) & long_return;
default:
DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrpartition\n",
vp->magic));
}
return NULL;
}
/*********************
*
* Internal implementation functions
*
*********************/
static int HRP_index;
static void
Init_HR_Partition(void)
{
DEBUGMSGTL(("host/hr_partition", "Init_HR_Partition\n"));
HRP_DiskIndex = Get_Next_HR_Disk();
if (HRP_DiskIndex != -1)
HRP_DiskIndex &= ((1 << HRDEV_TYPE_SHIFT) - 1);
DEBUGMSGTL(("host/hr_partition", "... %d\n",HRP_DiskIndex));
HRP_index = -1;
}
static int
Get_Next_HR_Partition(void)
{
char string[1024];
int fd;
DEBUGMSGTL(("host/hr_partition", "Get_Next_HR_Partition %d\n",HRP_DiskIndex));
if (HRP_DiskIndex == -1) {
return 0;
}
HRP_index++;
while (Get_Next_HR_Disk_Partition(string, sizeof(string), HRP_index) != -1) {
DEBUGMSGTL(("host/hr_partition",
"Get_Next_HR_Partition: %s (:%d)\n",
string, HRP_index));
#ifdef O_NDELAY
fd = open(string, O_RDONLY|O_NDELAY);
#else
fd = open(string, O_RDONLY);
#endif
if (fd != -1) {
close(fd);
return HRP_index + 1;
} else if (errno == EBUSY) {
return HRP_index + 1;
}
HRP_index++;
}
/*
* Finished with this disk, try the next
*/
Init_HR_Partition();
return (Get_Next_HR_Partition());
}
static void
Save_HR_Partition(int disk_idx, int part_idx)
{
HRP_savedDiskIndex = disk_idx;
HRP_savedPartIndex = part_idx;
(void) Get_Next_HR_Disk_Partition(HRP_savedName, sizeof(HRP_savedName), HRP_index);
#ifdef NETSNMP_CAN_GET_DISK_LABEL
(void) Get_HR_Disk_Label(HRP_savedLabel, sizeof(HRP_savedLabel), HRP_savedName);
#endif
}