hr_disk.c

ucd-snmp源代码

/*
 *  Host Resources MIB - disk device group implementation - hr_disk.c
 *
 */

#include <config.h>

#ifdef dynix
#if HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#endif

#include "host_res.h"
#include "hr_disk.h"
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif

#include <fcntl.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_KVM_H
#include <kvm.h>
#endif
#if HAVE_DIRENT_H
#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
#if HAVE_SYS_IOCTL_H
#include <sys/ioctl.h>
#endif

#if HAVE_SYS_DKIO_H
#include <sys/dkio.h>
#endif
#if HAVE_SYS_DISKIO_H	/* HP-UX only ? */
#include <sys/diskio.h>
#endif
#if HAVE_LINUX_HDREG_H
#include <linux/hdreg.h>
#endif
#if HAVE_SYS_DISKLABEL_H
#define DKTYPENAMES
#include <sys/disklabel.h>
#endif
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif

#if HAVE_LIMITS_H
#include <limits.h>
#endif

#ifdef linux
/*
 * define BLKGETSIZE from <linux/fs.h>:
 * Note: cannot include this file completely due to errors with redefinition
 * of structures (at least with older linux versions) --jsf
 */
#define BLKGETSIZE _IO(0x12,96) /* return device size */
#endif

#include "agent_read_config.h"
#include "read_config.h"

#define HRD_MONOTONICALLY_INCREASING

	/*********************
	 *
	 *  Kernel & interface information,
	 *   and internal forward declarations
	 *
	 *********************/

void  Init_HR_Disk (void);
int   Get_Next_HR_Disk (void);
int   Get_Next_HR_Disk_Partition (char *, int);
static void  Add_HR_Disk_entry (const char *, int, int, int, int, const char *, int, int);
static void  Save_HR_Disk_General (void);
static void  Save_HR_Disk_Specific (void);
static int   Query_Disk (int, const char *);
static int   Is_It_Writeable (void);
static int   What_Type_Disk (void);
static int   Is_It_Removeable (void);
static const char *describe_disk (int);

int header_hrdisk (struct variable *,oid *, size_t *, int, size_t *, WriteMethod **);

static int HRD_type_index;
static int HRD_index;
static char HRD_savedModel[40];
static long HRD_savedCapacity = 1044;
static int  HRD_savedFlags;
static time_t HRD_history[HRDEV_TYPE_MASK];

#ifdef DIOC_DESCRIBE
static disk_describe_type HRD_info;
static capacity_type      HRD_cap;

static int  HRD_savedIntf_type;
static int  HRD_savedDev_type;
#endif

#ifdef DKIOCINFO
static struct dk_cinfo    HRD_info;
static struct dk_geom     HRD_cap;

static int  HRD_savedCtrl_type;
#endif

#ifdef HAVE_LINUX_HDREG_H
static struct hd_driveid HRD_info;
#endif

#ifdef DIOCGDINFO
static struct disklabel HRD_info;
#endif

static void parse_disk_config(const char *, char *);
static void free_disk_config(void);

	/*********************
	 *
	 *  Initialisation & common implementation functions
	 *
	 *********************/

#define	HRDISK_ACCESS		1
#define	HRDISK_MEDIA		2
#define	HRDISK_REMOVEABLE	3
#define	HRDISK_CAPACITY		4

struct variable4 hrdisk_variables[] = {
    { HRDISK_ACCESS,    ASN_INTEGER, RONLY, var_hrdisk, 2, {1,1}},
    { HRDISK_MEDIA,     ASN_INTEGER, RONLY, var_hrdisk, 2, {1,2}},
    { HRDISK_REMOVEABLE,ASN_INTEGER, RONLY, var_hrdisk, 2, {1,3}},
    { HRDISK_CAPACITY,  ASN_INTEGER, RONLY, var_hrdisk, 2, {1,4}}
};
oid hrdisk_variables_oid[] = { 1,3,6,1,2,1,25,3,6};


void init_hr_disk(void)
{
    int i;

    init_device[ HRDEV_DISK ] = Init_HR_Disk;	
    next_device[ HRDEV_DISK ] = Get_Next_HR_Disk;
    save_device[ HRDEV_DISK ] = Save_HR_Disk_General;	
#ifdef HRD_MONOTONICALLY_INCREASING
    dev_idx_inc[ HRDEV_DISK ] = 1;
#endif

#if defined(linux)
    Add_HR_Disk_entry ( "/dev/hd%c%d", -1, -1, 'a', 'l', "/dev/hd%c", 1, 15 );
    Add_HR_Disk_entry ( "/dev/sd%c%d", -1, -1, 'a', 'p', "/dev/sd%c", 1, 15 );
    Add_HR_Disk_entry ( "/dev/md%d",   -1, -1,   0,   3, "/dev/md%d", 0, 0 );
    Add_HR_Disk_entry ( "/dev/fd%d",   -1, -1,   0,   1, "/dev/fd%d", 0, 0 );
#elif defined(hpux)
#if defined(hpux10) || defined(hpux11)
    Add_HR_Disk_entry ( "/dev/rdsk/c%dt%xd%d", 0, 1, 0, 15, "/dev/rdsk/c%dt%xd0", 0, 4 );
#else /* hpux9 */
    Add_HR_Disk_entry ( "/dev/rdsk/c%dd%xs%d", 201, 201, 0, 15, "/dev/rdsk/c%dd%xs0", 0, 4 );
#endif
#elif defined(solaris2)
    Add_HR_Disk_entry ( "/dev/rdsk/c%dt%dd0s%d", 0, 1, 0, 15, "/dev/rdsk/c%dt%dd0s0", 0, 7 );
    Add_HR_Disk_entry ( "/dev/rdsk/c%dd%ds%d",   0, 1, 0, 15, "/dev/rdsk/c%dd%ds0", 0, 7 );
#elif defined(freebsd4)
    Add_HR_Disk_entry ( "/dev/ad%ds%d%c", 0, 1, 1, 4, "/dev/ad%ds%d", 'a', 'h');
    Add_HR_Disk_entry ( "/dev/da%ds%d%c", 0, 1, 1, 4, "/dev/da%ds%d", 'a', 'h');
#elif defined(freebsd3)
    Add_HR_Disk_entry ( "/dev/wd%ds%d%c", 0, 1, 1, 4, "/dev/wd%ds%d", 'a', 'h');
    Add_HR_Disk_entry ( "/dev/sd%ds%d%c", 0, 1, 1, 4, "/dev/sd%ds%d", 'a', 'h');
#elif defined(freebsd2)
    Add_HR_Disk_entry ( "/dev/wd%d%c", -1, -1, 0, 3, "/dev/wd%d", 'a', 'h');
    Add_HR_Disk_entry ( "/dev/sd%d%c", -1, -1, 0, 3, "/dev/sd%d", 'a', 'h');
#elif defined(netbsd1)
    Add_HR_Disk_entry ( "/dev/wd%d%c", -1, -1, 0, 3, "/dev/wd%dc", 'a', 'h');
    Add_HR_Disk_entry ( "/dev/sd%d%c", -1, -1, 0, 3, "/dev/sd%dc", 'a', 'h');
#endif

    device_descr[ HRDEV_DISK ] = describe_disk;	
    HRD_savedModel[0] = '\0';
    HRD_savedCapacity = 0;

    for ( i=0 ; i<HRDEV_TYPE_MASK ; ++i )
	HRD_history[i] = -1;

    REGISTER_MIB("host/hr_disk", hrdisk_variables, variable4, hrdisk_variables_oid);

    snmpd_register_config_handler("ignoredisk", parse_disk_config,
				  free_disk_config, "name");
}

#define ITEM_STRING	1
#define ITEM_SET	2
#define ITEM_STAR	3
#define ITEM_ANY	4

typedef unsigned char details_set[32];

typedef struct _conf_disk_item {
    int item_type;	/* ITEM_STRING, ITEM_SET, ITEM_STAR, ITEM_ANY */
    void *item_details;	/* content depends upon item_type */
    struct _conf_disk_item *item_next;
} conf_disk_item;

typedef struct _conf_disk_list {
    conf_disk_item *list_item;
    struct _conf_disk_list *list_next;
} conf_disk_list;
static conf_disk_list *conf_list;

static int match_disk_config(const char *);
static int match_disk_config_item(const char *, conf_disk_item *);

static void
parse_disk_config(const char *token, char *cptr)
{
    conf_disk_list *d_new;
    conf_disk_item *di_curr;
    details_set *d_set;
    char *name, *p, *d_str, c;
    unsigned int i, neg, c1, c2;

    name = strtok(cptr, " \t");
    if (!name) {
	config_perror("Missing NAME parameter");
	return;
    }
    d_new = (conf_disk_list *)malloc(sizeof(conf_disk_list));
    if (!d_new) {
	config_perror("Out of memory");
	return;
    }
    di_curr = (conf_disk_item *)malloc(sizeof(conf_disk_item));
    if (!di_curr) {
	config_perror("Out of memory");
	return;
    }
    d_new->list_item = di_curr;
    for (;;) {
	if (*name == '?') {
	    di_curr->item_type = ITEM_ANY;
	    di_curr->item_details = (void *)0;
	    name++;
	} else if (*name == '*') {
	    di_curr->item_type = ITEM_STAR;
	    di_curr->item_details = (void *)0;
	    name++;
	} else if (*name == '[') {
	    d_set = (details_set *)malloc(sizeof(details_set));
	    if (!d_set) {
		config_perror("Out of memory");
		return;
	    }
	    for (i = 0; i < sizeof(details_set); i++)
		(*d_set)[i] = (unsigned char)0;
	    name++;
	    if (*name == '^' || *name == '!') {
		neg = 1;
		name++;
	    } else {
		neg = 0;
	    }
	    while (*name && *name != ']') {
		c1 = ((unsigned int)*name++) & 0xff;
		if (*name == '-' && *(name + 1) != ']') {
		    name++;
		    c2 = ((unsigned int)*name++) & 0xff;
		} else {
		    c2 = c1;
		}
		for (i = c1; i <= c2; i++)
		    (*d_set)[i / 8] |= (unsigned char)(1 << (i % 8));
	    }
	    if (*name != ']') {
		config_perror("Syntax error in NAME: invalid set specified");
		return;
	    }
	    if (neg) {
		for (i = 0; i < sizeof(details_set); i++)
		    (*d_set)[i] = (*d_set)[i] ^ (unsigned char)0xff;
	    }
	    di_curr->item_type = ITEM_SET;
	    di_curr->item_details = (void *)d_set;
	    name++;
	} else {
	    for (p = name; *p != '\0' && *p != '?' && *p != '*' && *p != '[';
		p++);
	    c = *p;
	    *p = '\0';
	    d_str = (char *)malloc(strlen(name) + 1);
	    if (!d_str) {
		config_perror("Out of memory");
		return;
	    }
	    strcpy(d_str, name);
	    *p = c;
	    di_curr->item_type = ITEM_STRING;
	    di_curr->item_details = (void *)d_str;
	    name = p;
	}
	if (!*name) {
	    di_curr->item_next = (conf_disk_item *)0;
	    break;
	}
	di_curr->item_next = (conf_disk_item *)malloc(sizeof(conf_disk_item));
	if (!di_curr->item_next) {
	    config_perror("Out of memory");
	    return;
	}
	di_curr = di_curr->item_next;
    }
    d_new->list_next = conf_list;
    conf_list = d_new;
}

static void
free_disk_config(void)
{
    conf_disk_list *d_ptr = conf_list, *d_next;
    conf_disk_item *di_ptr, *di_next;

    while (d_ptr) {
	d_next = d_ptr->list_next;
	di_ptr = d_ptr->list_item;
	while (di_ptr) {
	    di_next = di_ptr->item_next;
	    if (di_ptr->item_details)
		free(di_ptr->item_details);
	    free((void *)di_ptr);
	    di_ptr = di_next;
	}
	free((void *)d_ptr);
	d_ptr = d_next;
    }
    conf_list = (conf_disk_list *)0;
}

static int
match_disk_config_item(const char *name, conf_disk_item *di_ptr)
{
    int result = 0;
    size_t len;
    details_set *d_set;
    unsigned int c;

    if (di_ptr) {
	switch (di_ptr->item_type) {
	    case ITEM_STRING:
		len = strlen((const char *)di_ptr->item_details);
		if (!strncmp(name, (const char *)di_ptr->item_details, len))
		    result = match_disk_config_item(name + len,
						    di_ptr->item_next);
		break;
	    case ITEM_SET:
		if (*name) {
		    d_set = (details_set *)di_ptr->item_details;
		    c = ((unsigned int)*name) & 0xff;
		    if ((*d_set)[c / 8] & (unsigned char)(1 << (c % 8)))
			result = match_disk_config_item(name + 1,
							di_ptr->item_next);
		}
		break;
	    case ITEM_STAR:
		if (di_ptr->item_next) {
		    for (; !result && *name; name++)
			result = match_disk_config_item(name,
							di_ptr->item_next);
		} else {
		    result = 1;
		}
		break;
	    case ITEM_ANY:
		if (*name)
		    result = match_disk_config_item(name + 1,
						    di_ptr->item_next);
		break;
	}
    } else {
	if (*name == '\0')
	    result = 1;
    }

    return result;
}

static int
match_disk_config(const char *name)
{
    conf_disk_list *d_ptr = conf_list;

    while (d_ptr) {
	if (match_disk_config_item(name, d_ptr->list_item))
	    return 1;		/* match found in ignorelist */
	d_ptr = d_ptr->list_next;
    }

    /* no match in ignorelist */
    return 0;
}

/*
  header_hrdisk(...
  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_hrdisk(struct variable *vp,
	      oid *name,
	      size_t *length,
	      int exact,
	      size_t *var_len,
	      WriteMethod **write_method)
{
#define HRDISK_ENTRY_NAME_LENGTH	11
    oid newname[MAX_OID_LEN];
    int disk_idx, LowIndex = -1;
    int result;

    DEBUGMSGTL(("host/hr_disk", "var_hrdisk: "));
    DEBUGMSGOID(("host/hr_disk", name, *length));
    DEBUGMSG(("host/hr_disk"," %d\n", exact));
    
    memcpy( (char *)newname,(char *)vp->name, (int)vp->namelen * sizeof(oid));
	/* Find "next" disk entry */

    Init_HR_Disk();
    for ( ;; ) {
        disk_idx = Get_Next_HR_Disk();
        if ( disk_idx == -1 )
	    break;
	newname[HRDISK_ENTRY_NAME_LENGTH] = disk_idx;
        result = snmp_oid_compare(name, *length, newname, (int)vp->namelen + 1);
        if (exact && (result == 0)) {
	    LowIndex = disk_idx;
	    Save_HR_Disk_Specific();
            break;
	}
	if ((!exact && (result < 0)) &&
		( LowIndex == -1 ||  disk_idx < LowIndex )) {
	    LowIndex = disk_idx;
	    Save_HR_Disk_Specific();
#ifdef HRD_MONOTONICALLY_INCREASING
	    break;
#endif
        }
    }

    if ( LowIndex == -1 ) {
      DEBUGMSGTL(("host/hr_disk", "... index out of range\n"));
      return(MATCH_FAILED);
    }