system_mib.c

ucd-snmp源代码

  gethostname(sysName,sizeof(sysName));
#else
#ifdef HAVE_UNAME
  strncpy(sysName,utsName.nodename,sizeof(sysName));
#else
#if HAVE_EXECV
  sprintf(extmp.command,"%s -n",UNAMEPROG);
  /* setup defaults */
  extmp.type = EXECPROC;
  extmp.next = NULL;
  exec_command(&extmp);
  strncpy(sysName,extmp.output, sizeof(sysName));
  sysName[strlen(sysName)-1] = 0; /* chomp new line */
#else
  strcpy(sysName, "unknown" );
#endif /* HAVE_EXECV */
#endif /* HAVE_UNAME */
#endif /* HAVE_GETHOSTNAME */

  /* register ourselves with the agent to handle our mib tree */
  REGISTER_MIB("mibII/system", system_variables, variable2,
               system_variables_oid);

  if ( ++system_module_count == 3 )
	REGISTER_SYSOR_ENTRY( system_module_oid,
		"The MIB module for SNMPv2 entities");
  
  sysContactSet = sysLocationSet = sysNameSet = 0;

  /* register our config handlers */
  snmpd_register_config_handler("syslocation", system_parse_config_sysloc,
                                NULL, "location");
  snmpd_register_config_handler("syscontact", system_parse_config_syscon,
                                NULL,"contact-name");
  snmpd_register_config_handler("sysname", system_parse_config_sysname,
                                NULL,"node-name");
  snmpd_register_config_handler("psyslocation", system_parse_config_sysloc,
                                NULL, NULL);
  snmpd_register_config_handler("psyscontact", system_parse_config_syscon,
                                NULL, NULL);
  snmpd_register_config_handler("psysname", system_parse_config_sysname,
                                NULL, NULL);
  snmpd_register_config_handler("sysservices", system_parse_config_sysServices,
                                NULL,"NUMBER");
  snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
			 system_store, NULL);

}


	/*********************
	 *
	 *  System specific implementation functions
	 *
	 *********************/

#ifdef USING_MIBII_SYSORTABLE_MODULE
extern struct timeval sysOR_lastchange;
#endif

u_char	*
var_system(struct variable *vp,
	   oid *name,
	   size_t *length,
	   int exact,
	   size_t *var_len,
	   WriteMethod **write_method)
{

    struct timeval now;

    if (header_generic(vp, name, length, exact, var_len, write_method) == MATCH_FAILED )
	return NULL;

    switch (vp->magic){
        case VERSION_DESCR:
            *var_len = strlen(version_descr);
            return (u_char *)version_descr;
        case VERSIONID:
            *var_len = version_id_len*sizeof(version_id[0]);
            return (u_char *)version_id;
        case UPTIME:
            gettimeofday(&now, NULL);
	    long_return = timeval_uptime( &now );
            return ((u_char *) &long_return);
        case SYSCONTACT:
            *var_len = strlen(sysContact);
            *write_method = writeSystem;
            return (u_char *)sysContact;
        case SYSTEMNAME:
            *var_len = strlen(sysName);
            *write_method = writeSystem;
            return (u_char *)sysName;
        case SYSLOCATION:
            *var_len = strlen(sysLocation);
            *write_method = writeSystem;
            return (u_char *)sysLocation;
        case SYSSERVICES:
#if NO_DUMMY_VALUES
            if (!sysServicesConfiged)
                return NULL;
#endif
            long_return = sysServices;
            return (u_char *)&long_return;

#ifdef USING_MIBII_SYSORTABLE_MODULE
        case SYSORLASTCHANGE:
	      long_return = timeval_uptime( &sysOR_lastchange );
              return ((u_char *) &long_return);
#endif
              
	default:
	    DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_system\n", vp->magic));
    }
    return NULL;
}



int
writeSystem(int action,	     
	    u_char *var_val,
	    u_char var_val_type,
	    size_t var_val_len,
	    u_char *statP,
	    oid *name,
	    size_t name_len)
{
    u_char *cp;
    char *buf = NULL, *oldbuf = NULL;
    int count, *setvar = NULL;

    switch((char)name[7]){
      case SYSCONTACT:
        buf    = sysContact;
        oldbuf = oldsysContact;
	setvar = &sysContactSet;
        break;
      case SYSTEMNAME:
        buf    = sysName;
        oldbuf = oldsysName;
	setvar = &sysNameSet;
        break;
      case SYSLOCATION:
        buf    = sysLocation;
        oldbuf = oldsysLocation;
	setvar = &sysLocationSet;
        break;
      default:
	return SNMP_ERR_GENERR;		/* ??? */
    }

    switch (action) {
	case RESERVE1:		/* Check values for acceptability */
	    if (var_val_type != ASN_OCTET_STR){
                snmp_log(LOG_ERR, "not string\n");
		return SNMP_ERR_WRONGTYPE;
	    }
	    if (var_val_len > sizeof(sysLocation)-1){
                snmp_log(LOG_ERR, "bad length\n");
		return SNMP_ERR_WRONGLENGTH;
	    }
	    
	    for(cp = var_val, count = 0; count < (int)var_val_len; count++, cp++){
		if (!isprint(*cp)){
                    snmp_log(LOG_ERR, "not print %x\n", *cp);
		    return SNMP_ERR_WRONGVALUE;
		}
	    }
	    if (setvar != NULL && *setvar < 0) {
		/*  The object is set in a read-only configuration file.  */
		return SNMP_ERR_NOTWRITABLE;
	    }
	    break;

	case RESERVE2:		/* Allocate memory and similar resources */

		/* Using static strings, so nothing needs to be done */
	    break;

	case ACTION:		/* Perform the SET action (if reversible) */

		/* Save the old value, in case of UNDO */
	    strcpy( oldbuf, buf);
	    memcpy( buf, var_val, var_val_len);
	    buf[var_val_len] = 0;
	    break;

	case UNDO:		/* Reverse the SET action and free resources */

	    strcpy( buf, oldbuf);
	    oldbuf[0] = 0;
	    break;

	case COMMIT:
	    if (setvar != NULL) {
		*setvar = 1;
	    }
	    snmp_save_persistent(ds_get_string(DS_LIBRARY_ID, DS_LIB_APPTYPE));
	    (void)snmp_call_callbacks(SNMP_CALLBACK_LIBRARY,
				      SNMP_CALLBACK_STORE_DATA, NULL);
	    snmp_clean_persistent(ds_get_string(DS_LIBRARY_ID,DS_LIB_APPTYPE));

	case FREE:		/* Free any resources allocated */

		/* No resources have been allocated, but "empty" the 'oldbuf' */
	    oldbuf[0] = 0;
	    break;
    }
    return SNMP_ERR_NOERROR;
} /* end of writeSystem */

	/*********************
	 *
	 *  Internal implementation functions - None
	 *
	 *********************/

#ifdef WIN32
void
getSysDescr(void)
{
    OSVERSIONINFOEX osvi;
    BOOL bOsVersionInfoEx;

    /* Try calling GetVersionEx using the OSVERSIONINFOEX structure.
     * If that fails, try using the OSVERSIONINFO structure.
     */

    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

    if (!(bOsVersionInfoEx = GetVersionEx((OSVERSIONINFO *)&osvi))) {
	/* If OSVERSIONINFOEX doesn't work, try OSVERSIONINFO. */
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	if (!GetVersionEx((OSVERSIONINFO *)&osvi)) {
 	    return;
	}
    }
    sprintf(version_descr, "Software:");

    switch (osvi.dwPlatformId) {

    case VER_PLATFORM_WIN32_NT:
	if (osvi.dwMajorVersion <= 4) {
	    sprintf(version_descr, "%s %s", version_descr, 
		    "Microsoft Windows NT ");
	} else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0) {
	    sprintf(version_descr, "%s %s", version_descr,
		    "Microsoft Windows 2000");
	} else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1) {
	    sprintf(version_descr, "%s %s", version_descr, "Whistler ");
	}

	/*  Display version, service pack (if any), and build number.  */
	sprintf(version_descr, "%s Version %d.%d %s (Build %d)",
		version_descr,
		osvi.dwMajorVersion,
		osvi.dwMinorVersion,
		osvi.szCSDVersion,
		osvi.dwBuildNumber & 0xFFFF);
	break;

    case VER_PLATFORM_WIN32_WINDOWS:
	if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0) {
	    sprintf(version_descr, "%s %s", version_descr, 
		    "Microsoft Windows 95");
	    if (osvi.szCSDVersion[1] == 'C') {
		sprintf(version_descr, "%s %s", version_descr, "OSR2");
	    }
	} 
	
	if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10) {
	    sprintf(version_descr, "%s %s", version_descr,
		    "Microsoft Windows 98");
	    if (osvi.szCSDVersion[1] == 'A') {
		sprintf(version_descr, "%s %s", version_descr, "SE");
	    }
	} 
	
	if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90) {
	    sprintf(version_descr, "%s %s", version_descr, 
		    "Microsoft Windows Me");
	} 
	break;
	
    case VER_PLATFORM_WIN32s:
	sprintf(version_descr, "%s %s", version_descr, "Microsoft Win32s");
	break;
    }
}
#endif