diff --git a/net-analyzer/net-snmp/Manifest b/net-analyzer/net-snmp/Manifest index 031752be..b4ba8c83 100644 --- a/net-analyzer/net-snmp/Manifest +++ b/net-analyzer/net-snmp/Manifest @@ -1,3 +1,4 @@ +AUX CVE-2008-6123.patch 867 RMD160 1e8b6521ae0955681493c1ba594eb0344183e147 SHA1 3742c405fab9ac829acc93383bc39ba5b39962e9 SHA256 31a9b72b252582cd84e7f673b670ebbd2153dc719894aa668a48b24d6ba516f6 AUX net-snmp-5.1.2-snmpconf-selinux.patch 286 RMD160 c78fd9d2a563ebafd21aa85a582b989a805eb645 SHA1 159990e855cfeb50ac3657d1b97eda181d4ffb9e SHA256 70b4bdaa243efd5ae5703b3272063314fc56b6e2333f7c650b635ddab141f874 AUX net-snmp-5.4-exec-crash.patch 567 RMD160 fe110ace0ae451a8cf25d18d4133fb0d85dcaf5c SHA1 4a4538958e4c805981e1f0da4d6f1980a03aeab6 SHA256 2c4d3d281380d394d0d349c37839bb89f3d82d3e1c43513e042d24126441741c AUX net-snmp-5.4-makefile.patch 597 RMD160 90f8e6db0a05fd21c06e98b65b4bbd377f931fe9 SHA1 2ff51b2ab2df2224dd34ca1af16430fbf0b97927 SHA256 fd8c6ceda9c5d99cd92f81a7977d2134960ee14fac3ab9f1f8c6d03c6a69edb1 @@ -7,17 +8,22 @@ AUX net-snmp-5.4.1-incorrect-hrFSStorageIndex.patch 16053 RMD160 1d33a23b165946f AUX net-snmp-5.4.1-ipAddressTable-crash-with-double-free.patch 4740 RMD160 305f962976c6afc39b0ee37706f34d05ea768874 SHA1 93b806c407048cba4f5c63137df1e819c83d0010 SHA256 0872a11f48106f1a2a9c4a8a894abe31b04ee607bdfd44b8207c8e659213ef31 AUX net-snmp-5.4.1-perl-asneeded.patch 1219 RMD160 caced600c35165603069e62a17a664d7a0180586 SHA1 89bedb2424d65176a9bfba8c9b318b1d50b5b3ed SHA256 42640b545363cd5c6c7eef6b17b10c1d256e189ceb7b7c874baa4041de24e151 AUX net-snmp-5.4.1-process-count-race.patch 1489 RMD160 221f218270b83afec95d1efd260109b8baf05626 SHA1 3986f4789c145dd7182bf5f7d94a1cda0504ce5c SHA256 74a6e001de7a855079be988dd0cb23190095082e1a9adaefb9a9cac677ffa116 +AUX net-snmp-5.4.1-sensors3-version_detect.patch 1391 RMD160 eba5c1cba2fc5d0484143eb4b41f656f5f72bee4 SHA1 8c8ebcc9e4725e91cc7b07cdd45cbcf6e2ed806e SHA256 e18f7bd358c4f587793f9e9250489200d2708b50529dfe222f04b71617fa1e59 +AUX net-snmp-5.4.1-sensors3.patch 48401 RMD160 9899c587eb252cf9edac758133a420ef0307c315 SHA1 cd5adc2fab5c1d58c8a318d34aa3fcd4fd25c455 SHA256 e74e06a5f23350a2851fdc9f419335767d898ec66dd809e1c0413e39034d6f53 AUX net-snmp-5.4.1-suppresssuppress-annoying.patch 800 RMD160 aa23a30241ae64aeed6a08a630326fd7c2e0f9fe SHA1 2b99c56d1f659f324c5676d48ab257ea3b55467f SHA256 f5249b782079be96256ab6e7a0d398c04dfbcabffa7f4c716fe1abd39897aabe AUX net-snmp-5.4.1.1-rpm5-1.patch 2258 RMD160 e29716d03c86874579c1fb2f3edafd5867991286 SHA1 3a403ef15bb2edf151531b5fd291df6937ef216e SHA256 ad958fcf18565930e428027e6ea60546865947b149255b2e166e9fe2a8726ee5 AUX net-snmp-lm_sensors.patch 13686 RMD160 b2e67c6f5a5347442fbaa97c9ce209f1d9bed194 SHA1 3e795339fc93306a4d662feeaa16faca2509a058 SHA256 51dc2363a687d9f4e65b0a59e767b33129d07623a0b4da07b685e406d2576b86 AUX rpm514-netsnmp-5.4.1.1.patch 11813 RMD160 de2ed34c72280d2da308a0f1e0b293d51f2c391c SHA1 5856bc7531c40e7b9be267b5cd117d6ddf7dc043 SHA256 801039ba6a484fe83c7e1940e4227fccafe4c7cf1962f9fcda01e70869abaa28 AUX snmpd.conf 598 RMD160 c72a20fe6d4682ceea533587762782d62906b630 SHA1 51ebdca93c68ca04b7f402fad4f504422ec2c6cf SHA256 1f4f07b831c3227588fd546423137ed5c60a602fbee13b0d66edd801e4e7d598 +AUX snmpd.init 1054 RMD160 6cc814d19524e1899b4bb9539ee9752304451bc9 SHA1 ed2b1a4bd7da84ca6294c0df66cace2e7c0ffe72 SHA256 824ae327db4d76fe4cdc882f06ac989e510ee1ee96c90137ab84bc18446ba8b6 AUX snmpd.rc7 706 RMD160 137d85e5f2b7cae62e214141aabcec495777007e SHA1 8d94d3bb2d3b43e20604030dc585c735685cf99b SHA256 93337ebeac92ec0073c896db0a4384beebf84ee17365bdc2594285fd33ac7dfe AUX snmptrapd.conf 635 RMD160 aba7b7196835bd359174156a527e13188f76e248 SHA1 0d296caa01c789455c3cd4c67cd81aca5547681d SHA256 902d73cb44446df060bf20e0c8ef0f8815d5b846f96d93894913d3309a3841b3 +AUX snmptrapd.init 624 RMD160 799faf488a62bc219d3765ed6d6283ca7764ad1c SHA1 1fdef5a0a29f181c2df31b9d7adc4d4ebb8b018c SHA256 0e6dae4ca0213be9f9311c8dacdf36e7fea05150db48d15660506d53abda5a39 AUX snmptrapd.rc7 557 RMD160 e67117fbcb0a6f8668cb1abbc8fcfcb548ebfdb5 SHA1 dcaac6c0f9e086e49f653f100e0c3f9a7f65db1d SHA256 3594345cdf3c9a5a04073ec11a54e4a19881b27288cdbf22874cca5d0a0f624c DIST net-snmp-5.4.1.1.tar.gz 5123861 RMD160 870b6a3e4eb28df3cbdf0df34d23f46bd7de8961 SHA1 cfeef748f242a7b25ad8eea95977ff277984e368 SHA256 b22ecb5e7f0907c20cc7fc9f1e1f31b1b4b2dd81abdc3e2e0bfddf8d060008a2 DIST net-snmp-5.4.2.1.tar.gz 5185390 RMD160 2148c42d486ed88f9cfc3ca1d50c68abcd7e3d63 SHA1 4f2df9ea62344fe840f493d0e08abe5de3697862 SHA256 11a8baf167f7bfff60d2590e050991400a3a082923dbcdbf85e0e0ce46eb247c EBUILD net-snmp-5.4.1.1-r1.ebuild 6268 RMD160 25fec5abaf38e6e75d14e4f939f4357b0c69303f SHA1 37fdffe833d285f3ea7aaddecfe65b02df58c831 SHA256 90f3bbdfce52ded6cae0435f7b7a703765740110562838f5be94dfdf72be8f0b EBUILD net-snmp-5.4.2.1-r1.ebuild 5507 RMD160 cbd1e959c886c16b2f6b10b0630d9962d851feec SHA1 cc2e52453d6bef2348f4bc61389d1214a10cefe3 SHA256 458fd9137cb1f72e616e164aac6d36264c774edd845ffdf1e67f7a323253b3cd +EBUILD net-snmp-5.4.2.1-r2.ebuild 5595 RMD160 b309b1e9d039575b5150a48869c9d7d9107cd621 SHA1 1646884a4ba6105ad25b06e75158c9f0f837d530 SHA256 87b29159a16852dfbb45965f2790deb0585f2abb555f86d8ccf9f485bb4bdeb9 MISC ChangeLog 330 RMD160 f08e45d855cbc97dc85d92d8b0b623d0af5fa7dc SHA1 3bcbbb0443295101f405c034bbe35981589743a0 SHA256 00f865659c797c793f6a316b93c821f819f5ff3c36c982d23280ade6d95a5e9c MISC metadata.xml 674 RMD160 102cd7df943ef25f0f462f2520fa77ceac3b5680 SHA1 90b51daab27e161a48feed336a348a8ecf0865c2 SHA256 233feade72f1b013bb5b0739478ab7200727db25a1d06977d0d122862565de24 diff --git a/net-analyzer/net-snmp/files/CVE-2008-6123.patch b/net-analyzer/net-snmp/files/CVE-2008-6123.patch new file mode 100644 index 00000000..b4b06f63 --- /dev/null +++ b/net-analyzer/net-snmp/files/CVE-2008-6123.patch @@ -0,0 +1,19 @@ +diff -Naur snmplib.orig/snmpUDPDomain.c snmplib/snmpUDPDomain.c +--- snmplib.orig/snmpUDPDomain.c 2007-10-11 22:46:30.000000000 +0200 ++++ snmplib/snmpUDPDomain.c 2009-07-10 23:41:37.000000000 +0200 +@@ -104,12 +110,12 @@ + char tmp[64]; + to = (struct sockaddr_in *) &(addr_pair->remote_addr); + if (to == NULL) { +- sprintf(tmp, "UDP: [%s]->unknown", ++ sprintf(tmp, "UDP: unknown->[%s]", + inet_ntoa(addr_pair->local_addr)); + } else { +- sprintf(tmp, "UDP: [%s]->", inet_ntoa(addr_pair->local_addr)); +- sprintf(tmp + strlen(tmp), "[%s]:%hd", ++ sprintf(tmp, "UDP: [%s]:%hu->", + inet_ntoa(to->sin_addr), ntohs(to->sin_port)); ++ sprintf(tmp + strlen(tmp), "[%s]", inet_ntoa(addr_pair->local_addr)); + } + return strdup(tmp); + } diff --git a/net-analyzer/net-snmp/files/net-snmp-5.4.1-sensors3-version_detect.patch b/net-analyzer/net-snmp/files/net-snmp-5.4.1-sensors3-version_detect.patch new file mode 100644 index 00000000..9159dd03 --- /dev/null +++ b/net-analyzer/net-snmp/files/net-snmp-5.4.1-sensors3-version_detect.patch @@ -0,0 +1,56 @@ +From: Gordon Malm + +Detect lm_sensors version and build accordingly. + +--- a/agent/mibgroup/hardware/sensors.h ++++ b/agent/mibgroup/hardware/sensors.h +@@ -1,13 +1,21 @@ + config_require(hardware/sensors/hw_sensors) + + #if defined(solaris) ++ + # if defined(HAVE_PICL_H) + config_require(hardware/sensors/picld_sensors) + # else + config_require(hardware/sensors/kstat_sensors) + # endif ++ + #else ++ ++# if defined(HAVE_LMSENSORS_V2) ++config_require(hardware/sensors/lmsensors_v2) ++# else + config_require(hardware/sensors/lmsensors_v3) ++# endif ++ + #endif + + //config_require(hardware/sensors/dummy_sensors) +--- a/configure.in ++++ b/configure.in +@@ -1909,6 +1909,25 @@ done + + AC_MSG_RESULT([$new_module_list.]) + ++echo " $new_module_list " | $GREP "ucd-snmp/lmsensorsMib" > /dev/null ++if test $? -eq 0 ; then ++ case $target_os in ++ linux*) ++ AC_CHECK_HEADER(sensors/sensors.h,,[AC_MSG_ERROR([asked to use lm_sensors but I couldn't find sensors/sensors.h])]) ++ ++ AC_MSG_CHECKING([lm_sensors version]) ++ AC_EGREP_CPP(lmsensors_v2,[ ++#include ++#if SENSORS_API_VERSION < 0x400 ++lmsensors_v2 ++#endif ++ ], [AC_DEFINE([HAVE_LMSENSORS_V2], [1], [Define if lm_sensors version 2.x])] ++ have_lmsensors_ver="2.x", have_lmsensors_ver="3.x or higher") ++ AC_MSG_RESULT([$have_lmsensors_ver]) ++ ;; ++ esac ++fi ++ + #--------------------- + # loop over module list + # diff --git a/net-analyzer/net-snmp/files/net-snmp-5.4.1-sensors3.patch b/net-analyzer/net-snmp/files/net-snmp-5.4.1-sensors3.patch new file mode 100644 index 00000000..8e4b09ba --- /dev/null +++ b/net-analyzer/net-snmp/files/net-snmp-5.4.1-sensors3.patch @@ -0,0 +1,1314 @@ +Source: http://cvs.fedoraproject.org/viewvc/devel/net-snmp/net-snmp-5.4.1-sensors3.patch + +--- + +351991: Port net-snmp to lm_sensors-3.x.x +Source: upstream, svn diff -r 16736:16739 +Reviewed-By: Jan Safranek + +Index: configure +=================================================================== +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/dummy_sensors.c +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/dummy_sensors.c 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,60 @@ ++#include ++#include ++#include ++#include ++ ++ ++void netsnmp_sensor_arch_init( void ) { ++ /* Nothing to do */ ++ DEBUGMSGTL(("sensors:arch", "Initialise Dummy Sensors module\n")); ++} ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ time_t now; ++ struct tm *tm; ++ netsnmp_sensor_info *sp; ++ ++ time(&now); ++ tm = localtime(&now); ++ ++ DEBUGMSGTL(("sensors:arch", "Reload Dummy Sensors module\n")); ++ ++ /* First pseudo-sensor - slowly-rising temperature */ ++ sp = sensor_by_name( "minute", NETSNMP_SENSOR_TYPE_TEMPERATURE ); ++ sp->value = tm->tm_min; ++ snprintf( sp->descr, 256, "Minute-based pseudo-sensor - slowly-rising temperature" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Second pseudo-sensor - quickly-rising temperature */ ++ sp = sensor_by_name( "second", NETSNMP_SENSOR_TYPE_TEMPERATURE ); ++ sp->value = tm->tm_sec; ++ snprintf( sp->descr, 256, "Second-based pseudo-sensor - quickly-rising temperature" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Third pseudo-sensor - annual fan speed */ ++ sp = sensor_by_name( "year", NETSNMP_SENSOR_TYPE_RPM ); ++ sp->value = tm->tm_year + 1900; ++ snprintf( sp->descr, 256, "RPM pseudo-sensor - annual fan speed" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Fourth pseudo-sensor - daily voltage */ ++ sp = sensor_by_name( "day", NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); ++ sp->value = tm->tm_mday-20; ++ snprintf( sp->descr, 256, "Day-based pseudo-sensor - positive or negative voltage" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Fifth pseudo-sensor - monthly voltage */ ++ sp = sensor_by_name( "month", NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); ++ sp->value = tm->tm_mon; ++ snprintf( sp->descr, 256, "Month-based pseudo-sensor - positive voltage" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Sixth pseudo-sensor - annual daily something */ ++ sp = sensor_by_name( "yday", NETSNMP_SENSOR_TYPE_OTHER ); ++ sp->value = tm->tm_yday; ++ snprintf( sp->descr, 256, "Day-based pseudo-sensor - annual something" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ return 0; ++} +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/dummy_sensors.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/dummy_sensors.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,13 @@ ++config_require(hardware/sensors/hw_sensors) ++ ++#if defined(solaris) ++# if defined(HAVE_PICL_H) ++config_require(hardware/sensors/picld_sensors) ++# else ++config_require(hardware/sensors/kstat_sensors) ++# endif ++#else ++config_require(hardware/sensors/lmsensors_v3) ++#endif ++ ++//config_require(hardware/sensors/dummy_sensors) +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/hw_sensors.c +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/hw_sensors.c 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,183 @@ ++#include ++#include ++#include ++#include ++ ++ ++extern NetsnmpCacheLoad netsnmp_sensor_arch_load; ++extern void netsnmp_sensor_arch_init( void ); ++static int _sensor_load( void ); ++static void _sensor_free( void ); ++ ++static int _sensorAutoUpdate = 0; /* 0 means on-demand caching */ ++static void _sensor_update_stats( unsigned int, void* ); ++ ++netsnmp_cache *_sensor_cache = NULL; ++netsnmp_container *_sensor_container = NULL; ++static int _sensor_idx = 0; ++ ++void init_hw_sensors( void ) { ++ ++ if ( _sensor_container ) ++ return; /* Already initialised */ ++ ++ DEBUGMSGTL(("sensors", "Initialise Hardware Sensors module\n")); ++ ++ /* ++ * Define a container to hold the basic list of sensors ++ * The four LM-SENSOR-MIB containers will be created in ++ * the relevant initialisation routine(s) ++ */ ++ _sensor_container = netsnmp_container_find("sensorTable:table_container"); ++ if ( NULL == _sensor_container ) { ++ snmp_log( LOG_ERR, "failed to create container for sensorTable"); ++ return; ++ } ++ netsnmp_sensor_arch_init( ); ++ ++ /* ++ * If we're sampling the sensor information automatically, ++ * then arrange for this to be triggered regularly. ++ * ++ * If we're not sampling these values regularly, ++ * create a suitable cache handler instead. ++ */ ++ if ( _sensorAutoUpdate ) { ++ DEBUGMSGTL(("sensors", "Reloading Hardware Sensors automatically (%d)\n", ++ _sensorAutoUpdate)); ++ snmp_alarm_register( _sensorAutoUpdate, SA_REPEAT, ++ _sensor_update_stats, NULL ); ++ } ++ else { ++ _sensor_cache = netsnmp_cache_create( 5, netsnmp_sensor_load, ++ netsnmp_sensor_free, NULL, 0 ); ++ DEBUGMSGTL(("sensors", "Reloading Hardware Sensors on-demand (%p)\n", ++ _sensor_cache)); ++ } ++} ++ ++void shutdown_hw_sensors( void ) { ++ _sensor_free(); ++} ++ ++/* ++ * Return the main sensor container ++ */ ++netsnmp_container *get_sensor_container( void ) { return _sensor_container; } ++ ++/* ++ * Return the main sensor cache control structure (if defined) ++ */ ++netsnmp_cache *get_sensor_cache( void ) { return _sensor_cache; } ++ ++ ++/* ++ * Wrapper routine for automatically updating sensor statistics ++ */ ++void ++_sensor_update_stats( unsigned int clientreg, void *data ) ++{ ++ _sensor_free(); ++ _sensor_load(); ++} ++ ++/* ++ * Wrapper routine for re-loading sensor statistics on demand ++ */ ++int ++netsnmp_sensor_load( netsnmp_cache *cache, void *data ) ++{ ++ return _sensor_load(); ++} ++ ++/* ++ * Wrapper routine for releasing expired sensor statistics ++ */ ++void ++netsnmp_sensor_free( netsnmp_cache *cache, void *data ) ++{ ++ _sensor_free(); ++} ++ ++ ++/* ++ * Architecture-independent processing of loading sensor statistics ++ */ ++static int ++_sensor_load( void ) ++{ ++ netsnmp_sensor_arch_load( NULL, NULL ); ++} ++ ++/* ++ * Architecture-independent release of sensor statistics ++ */ ++static void ++_sensor_free( void ) ++{ ++ netsnmp_sensor_info *sp; ++ ++ for (sp = CONTAINER_FIRST( _sensor_container ); ++ sp; ++ sp = CONTAINER_NEXT( _sensor_container, sp )) { ++ ++ sp->flags &= ~ NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++} ++ ++ ++/* ++ * Retrieve a sensor entry by name, ++ * or (optionally) insert a new one into the container ++ */ ++netsnmp_sensor_info * ++sensor_by_name( char *name, int create_type ) ++{ ++ netsnmp_sensor_info *sp; ++ ++ DEBUGMSGTL(("sensors:name", "Get sensor entry (%s)\n", name)); ++ ++ /* ++ * Look through the list for a matching entry ++ */ ++ /* .. or use a secondary index container ?? */ ++ for (sp = CONTAINER_FIRST( _sensor_container ); ++ sp; ++ sp = CONTAINER_NEXT( _sensor_container, sp )) { ++ ++ if ( !strcmp( name, sp->name )) ++ return sp; ++ } ++ ++ /* ++ * Not found... ++ */ ++ if ( create_type == NETSNMP_SENSOR_FIND_EXIST ) { ++ DEBUGMSGTL(("sensors:name", "No such sensor entry\n")); ++ return NULL; ++ } ++ ++ /* ++ * ... so let's create a new one, using the type supplied ++ */ ++ sp = SNMP_MALLOC_TYPEDEF( netsnmp_sensor_info ); ++ if ( sp ) { ++ strcpy( sp->name, name ); ++ sp->type = create_type; ++ /* ++ * Set up the index value. ++ * ++ * All this trouble, just for a simple integer. ++ * Surely there must be a better way? ++ */ ++ sp->idx.len = 1; ++ sp->idx.oids = SNMP_MALLOC_TYPEDEF( oid ); ++ sp->idx.oids[0] = ++_sensor_idx; ++ } ++ ++ DEBUGMSGTL(("sensors:name", "Create sensor entry (type = %d, index = %d\n", ++ create_type, _sensor_idx)); ++ CONTAINER_INSERT( _sensor_container, sp ); ++ return sp; ++} ++ +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/hw_sensors.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/hw_sensors.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1 @@ ++void init_hw_sensors( void ); +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/kstat_sensors.c +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/kstat_sensors.c 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,161 @@ ++#include ++#include ++#include ++#include ++ ++#include "util_funcs.h" ++#include ++ ++#include ++#include ++ ++void netsnmp_sensor_arch_init( void ) { ++ DEBUGMSGTL(("sensors:arch", "Initialise KStat Sensors module\n")); ++} ++ ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ netsnmp_sensor_info *sp; ++ ++ int i; ++ const char *fantypes[]={"CPU","PWR","AFB"}; ++ char name[ 256 ]; ++ ++ kstat_ctl_t *kc; ++ kstat_t *kp; ++ envctrl_fan_t *fan_info; ++ envctrl_ps_t *power_info; ++ envctrl_encl_t *enc_info; ++ ++ ++ DEBUGMSGTL(("sensors:arch", "Reload KStat Sensors module\n")); ++ ++ kc = kstat_open(); ++ if ( kc == 0) { ++ DEBUGMSGTL(("sensors:arch", "Couldn't open kstat\n")); ++ return 1; ++ } ++ ++ ++ /* ++ * Retrieve fan information ++ */ ++ kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_FANSTAT); ++ if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) { ++ DEBUGMSGTL(("sensors:arch", "No fan information\n")); ++ } else { ++ fan_info = (envctrl_fan_t *)kp->ks_data; ++ for (i=0; iks_ndata; i++) { ++ memset( name, 0, 256 ); ++ snprintf( name, 255, "%s%d", fantypes[fan_info->type], fan_info->instance ); ++ ++ sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_RPM ); ++ if ( sp ) { ++ sp->value = fan_info->fanspeed; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ snprintf( sp->descr, 255, "fan type %s number %d", ++ fantypes[fan_info->type], fan_info->instance ); ++ } ++ ++ fan_info++; ++ } ++ } ++ ++ ++ /* ++ * Retrieve Power Supply information ++ */ ++ kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_PSNAME); ++ if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) { ++ DEBUGMSGTL(("sensors:arch", "No PSU information\n")); ++ } else { ++ power_info = (envctrl_ps_t *)kp->ks_data; ++ for (i=0; iks_ndata; i++) { ++ memset( name, 0, 256 ); ++ snprintf( name, 255, "PSU%d", power_info->instance ); ++ ++ sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_TEMPERATURE); ++ if ( sp ) { ++ sp->value = power_info->ps_tempr; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ snprintf( sp->descr, 255, "power supply %d", power_info->instance ); ++ } ++ ++ power_info++; ++ } ++ } ++ ++ ++ /* ++ * Retrieve Enclosure information ++ */ ++ kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_ENCL); ++ if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) { ++ DEBUGMSGTL(("sensors:arch", "No enclosure information\n")); ++ } else { ++ enc_info = (envctrl_encl_t *)kp->ks_data; ++ for (i=0; iks_ndata; i++) { ++ /* ++ * The enclosure information covers several different types of sensor ++ */ ++ switch ( enc_info->type ) { ++ case ENVCTRL_ENCL_FSP: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure Front Panel\n")); ++ sp = sensor_by_name( "FSP", NETSNMP_SENSOR_TYPE_OTHER); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ break; ++ ++ case ENVCTRL_ENCL_AMBTEMPR: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure Ambient Temperature\n")); ++ sp = sensor_by_name( "Ambient", NETSNMP_SENSOR_TYPE_TEMPERATURE); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ break; ++ ++ case ENVCTRL_ENCL_CPUTEMPR: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure CPU Temperature\n")); ++ memset( name, 0, 256 ); ++ snprintf( name, 255, "CPU%d", enc_info->instance ); ++ sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_TEMPERATURE); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ snprintf( sp->descr, 255, "CPU%d temperature", enc_info->instance ); ++ } ++ break; ++ ++ case ENVCTRL_ENCL_BACKPLANE4: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure Backplane4\n")); ++ sp = sensor_by_name( "Backplane4", NETSNMP_SENSOR_TYPE_OTHER); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ break; ++ ++ case ENVCTRL_ENCL_BACKPLANE8: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure Backplane4\n")); ++ sp = sensor_by_name( "Backplane4", NETSNMP_SENSOR_TYPE_OTHER); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ break; ++ ++ default: ++ DEBUGMSGTL(("sensors:arch:detail", "Unrecognised Enclosure entry (%d)n", ++ enc_info->type)); ++ } ++ ++ enc_info++; ++ } ++ } ++ ++ return 0; ++} +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/kstat_sensors.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/kstat_sensors.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/lmsensors_v2.c +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/lmsensors_v2.c 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,75 @@ ++#include ++#include ++#include ++#include ++ ++#include "util_funcs.h" ++#include ++#include ++ ++void netsnmp_sensor_arch_init( void ) { ++ FILE *fp = fopen("/etc/sensors.conf", "r"); ++ DEBUGMSGTL(("sensors:arch", "Initialise LM Sensors module\n")); ++ sensors_init( fp ); ++} ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ netsnmp_sensor_info *sp; ++ const sensors_chip_name *chip; ++ const sensors_feature_data *data; ++ int chip_nr = 0; ++ ++ DEBUGMSGTL(("sensors:arch", "Reload LM Sensors module\n")); ++ while ((chip = sensors_get_detected_chips(&chip_nr))) { ++ int a = 0; ++ int b = 0; ++ ++ while ((data = sensors_get_all_features(*chip, &a, &b))) { ++ DEBUGMSGTL(("sensors:arch:detail", "get_all_features (%d, %d)\n", a, b)); ++ char *label = NULL; ++ double val; ++ int type = NETSNMP_SENSOR_TYPE_OTHER; ++ ++ if ((data->mode & SENSORS_MODE_R) && ++ (data->mapping == SENSORS_NO_MAPPING) && ++ !sensors_get_label(*chip, data->number, &label) && ++ !sensors_get_feature(*chip, data->number, &val)) { ++ ++ DEBUGMSGTL(("sensors:arch:detail", "%s = %f\n", label, val)); ++ /* ++ * Determine the type of sensor from the description. ++ * ++ * If the text being looked for below is not in the label of a ++ * given sensor (e.g., the temp1 sensor has been labeled 'CPU' ++ * rather than 'CPU temp') it will be categorised as OTHER. ++ */ ++ if (strstr(label, "V")) { ++ type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC; ++ } ++ if (strstr(label, "fan") || strstr(label, "Fan")) { ++ type = NETSNMP_SENSOR_TYPE_RPM; ++ } ++ if (strstr(label, "temp") || strstr(label, "Temp")) { ++ type = NETSNMP_SENSOR_TYPE_TEMPERATURE; ++ } ++ ++ /* ++ * Use this type to create a new sensor entry ++ * (inserting it in the appropriate sub-containers) ++ */ ++ sp = sensor_by_name( label, type ); ++ if ( sp ) { ++ sp->value = val; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ } ++ if (label) { ++ free(label); ++ label = NULL; ++ } ++ } /* end while data */ ++ } /* end while chip */ ++ ++ return 0; ++} +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/lmsensors_v2.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/lmsensors_v2.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/lmsensors_v3.c +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/lmsensors_v3.c 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,101 @@ ++#include ++#include ++#include ++#include ++ ++#include "util_funcs.h" ++#include ++#include ++ ++ ++void netsnmp_sensor_arch_init( void ) { ++ FILE *fp = fopen("/etc/sensors.conf", "r"); ++ DEBUGMSGTL(("sensors:arch", "Initialise v3 LM Sensors module\n")); ++ sensors_init( fp ); ++} ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ netsnmp_sensor_info *sp; ++ const sensors_chip_name *chip; ++ const sensors_feature *data; ++ const sensors_subfeature *data2; ++ int chip_nr = 0; ++ ++ DEBUGMSGTL(("sensors:arch", "Reload v3 LM Sensors module\n")); ++ while ((chip = sensors_get_detected_chips( NULL, &chip_nr))) { ++ int a = 0; ++ ++ while ((data = sensors_get_features( chip, &a))) { ++ DEBUGMSGTL(("sensors:arch:detail", "get_features (%s, %d)\n", data->name, data->number)); ++ int b = 0; ++ ++ ++ while ((data2 = sensors_get_all_subfeatures( chip, data, &b))) { ++ char *label = NULL; ++ double val; ++ int type = NETSNMP_SENSOR_TYPE_OTHER; ++ ++ DEBUGMSGTL(("sensors:arch:detail", " get_subfeatures (%s, %d)\n", data2->name, data2->number)); ++ /* ++ * Check the type of this subfeature, ++ * concentrating on the main "input" measurements. ++ */ ++ switch ( data2->type ) { ++ case SENSORS_SUBFEATURE_IN_INPUT: ++ type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC; ++ break; ++ case SENSORS_SUBFEATURE_FAN_INPUT: ++ type = NETSNMP_SENSOR_TYPE_RPM; ++ break; ++ case SENSORS_SUBFEATURE_TEMP_INPUT: ++ type = NETSNMP_SENSOR_TYPE_TEMPERATURE; ++ break; ++ case SENSORS_SUBFEATURE_VID: ++ type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC; ++ break; ++ default: ++ /* Skip everything other than these basic sensor features - ??? */ ++ DEBUGMSGTL(("sensors:arch:detail", " Skip type %x\n", data2->type)); ++ continue; ++ } ++ ++ /* ++ * Get the name and value of this subfeature ++ */ ++/* ++ if (!(label = sensors_get_label(chip, data))) { ++ DEBUGMSGTL(("sensors:arch:detail", " Can't get name (%s)\n", label)); ++ continue; ++ } ++ if (sensors_get_value(chip, data2->number, &val) < 0) { ++ DEBUGMSGTL(("sensors:arch:detail", " Can't get value (%f)\n", val)); ++ continue; ++ } ++*/ ++ if (!(label = sensors_get_label(chip, data)) || ++ (sensors_get_value(chip, data2->number, &val) < 0)) { ++ DEBUGMSGTL(("sensors:arch:detail", " Can't get name/value (%s, %f)\n", label, val)); ++ continue; ++ } ++ DEBUGMSGTL(("sensors:arch:detail", "%s = %f\n", label, val)); ++ ++ /* ++ * Use this type to create a new sensor entry ++ * (inserting it in the appropriate sub-containers) ++ */ ++ sp = sensor_by_name( label, type ); ++ if ( sp ) { ++ sp->value = val; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ if (label) { ++ free(label); ++ label = NULL; ++ } ++ } /* end while data2 */ ++ } /* end while data */ ++ } /* end while chip */ ++ ++ return 0; ++} +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/lmsensors_v3.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/lmsensors_v3.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/picld_sensors.c +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/picld_sensors.c 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,341 @@ ++#include ++#include ++#include ++#include ++ ++#include "util_funcs.h" ++#include ++ ++#include ++#include ++ ++void netsnmp_sensor_arch_init( void ) { ++ DEBUGMSGTL(("sensors:arch", "Initialise PICLd Sensors module\n")); ++ picl_initialize(); ++} ++ ++ ++/* ++ * Handle a numeric-valued sensor ++ */ ++static int ++read_num_sensor( picl_nodehdl_t childh, char *propval, float *value ) ++{ ++ picl_nodehdl_t sensorh; ++ picl_propinfo_t sensor_info; ++ picl_errno_t error_code; ++ ++ union valu { ++ char buf[PICL_PROPSIZE_MAX]; ++ uint32_t us4; ++ uint16_t us2; ++ int32_t is4; ++ int16_t is2; ++ float f; ++ } val; ++ ++ /* ++ * Retrieve the specified sensor information and value ++ */ ++ error_code = picl_get_propinfo_by_name(childh, propval, &sensor_info, &sensorh); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "sensor info lookup failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ error_code = picl_get_propval(sensorh, &val.buf, sensor_info.size); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "sensor value lookup failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ /* ++ * Check the validity (type and size) of this value ++ */ ++ if ( sensor_info.type == PICL_PTYPE_FLOAT ) { ++ *value = val.f; ++ } else if ( sensor_info.type == PICL_PTYPE_UNSIGNED_INT ) { ++ /* 16-bit or 32-bit unsigned integers */ ++ if ( sensor_info.size == 2 ) { ++ *value = val.us2; ++ } else if ( sensor_info.size == 4 ) { ++ *value = val.us4; ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "unsigned integer (%d bit)\n", ++ sensor_info.size * 8)); ++ return PICL_FAILURE; ++ } ++ } else if ( sensor_info.type == PICL_PTYPE_INT ) { ++ /* 16-bit or 32-bit signed integers */ ++ if ( sensor_info.size == 2 ) { ++ *value = val.is2; ++ } else if ( sensor_info.size == 4 ) { ++ *value = val.is4; ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "signed integer (%d bit)\n", ++ sensor_info.size * 8)); ++ return PICL_FAILURE; ++ } ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "unrecognised type (%d)\n", ++ sensor_info.type)); ++ return PICL_FAILURE; ++ } ++ ++ return error_code; ++} ++ ++static int ++process_num_sensor( picl_nodehdl_t childh, char *propname, char *propval, int typ ) ++{ ++ netsnmp_sensor_info *sp; ++ float value; ++ picl_errno_t error_code; ++ ++ sp = sensor_by_name( propname, typ ); ++ if ( !sp ) { ++ return -1; ++ } ++ ++ error_code = read_num_sensor( childh, propval, &value ); ++ if ( error_code == PICL_SUCCESS ) { ++ sp->value = value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "Failed to read %s sensor value (%d)\n", ++ propname, error_code)); ++ return -1; ++ } ++ return 0; ++} ++ ++ ++ ++/* ++ * Handle an enumeration-valued sensor ++ */ ++char *switch_settings[] = { "OFF","ON","NORMAL","LOCKED", ++ "UNKNOWN","DIAG","SECURE", ++ NULL }; ++char *led_settings[] = { "OFF","ON","BLINK", ++ NULL }; ++char *i2c_settings[] = { "OK", ++ NULL }; ++ ++static int ++read_enum_sensor( picl_nodehdl_t childh, float *value, char **options ) ++{ ++ picl_nodehdl_t sensorh; ++ picl_propinfo_t sensor_info; ++ picl_errno_t error_code; ++ char state[PICL_PROPSIZE_MAX]; ++ int i; ++ ++ /* ++ * Retrieve the specified sensor information and value ++ */ ++ error_code = picl_get_propinfo_by_name(childh, "State", &sensor_info, &sensorh); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "sensor info lookup failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ error_code = picl_get_propval(sensorh, state, sensor_info.size); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "sensor value lookup failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ /* ++ * Try to find a matching entry in the list of options. ++ * Note that some platforms may use upper or lower case ++ * versions of these enumeration values ++ * (so the checks are case insensitive) ++ */ ++ *value = 99; /* Dummy value */ ++ for ( i=0; options[i] != NULL; i++ ) { ++ if (strncasecmp(state, options[i], strlen(options[i])) == 0) { ++ *value = i; ++ return 0; ++ } ++ } ++ ++ DEBUGMSGTL(("sensors:arch:detail", "Enumeration state %s not matched\n", ++ state)); ++ return 0; /* Or an error ? */ ++} ++ ++static int ++process_enum_sensor( picl_nodehdl_t childh, char *propname, int typ, char **options ) ++{ ++ netsnmp_sensor_info *sp; ++ float value; ++ picl_errno_t error_code; ++ ++ sp = sensor_by_name( propname, typ ); ++ if ( !sp ) { ++ return -1; ++ } ++ ++ error_code = read_enum_sensor( childh, &value, options ); ++ if ( error_code == PICL_SUCCESS ) { ++ sp->value = value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "Failed to read %s sensor value (%d)\n", ++ propname, error_code)); ++ return -1; ++ } ++ return 0; ++} ++static int ++process_enum_sensor( picl_nodehdl_t childh, char *propname, int typ, char **options ) ++{ ++ return 0; ++} ++ ++ ++ ++/* ++ * Recursively walk through the tree of sensors ++ */ ++static int ++process_sensors( int level, picl_nodehdl_t nodeh ) { ++ picl_nodehdl_t childh, nexth; ++ char propname[ PICL_PROPNAMELEN_MAX ]; ++ char propclass[ PICL_CLASSNAMELEN_MAX ]; ++ picl_errno_t error_code; ++ ++ level++; ++ DEBUGMSGTL(("sensors:arch:detail", "process_sensors - level %d\n", level)); ++ ++ /* Look up the first child node at this level */ ++ error_code = pick_get_propval_by_name( nodeh, PICL_PROP_CHILD, ++ &childh, sizeof(childh)); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "Failed to get first child node (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ /* Step through the child nodes, retrieving the name and class of each one */ ++ while ( error_code == PICL_SUCCESS ) { ++ error_code = pick_get_propval_by_name( childh, PICL_PROP_NAME, ++ propname, sizeof(propname)-1); ++ if ( error_code != PICL_SUCCESS ) { ++ /* The Node With No Name */ ++ DEBUGMSGTL(("sensors:arch:detail", "get property name failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ error_code = pick_get_propval_by_name( childh, PICL_PROP_CLASSNAME, ++ propclass, sizeof(propclass)-1); ++ if ( error_code != PICL_SUCCESS ) { ++ /* The Classless Society */ ++ DEBUGMSGTL(("sensors:arch:detail", "get property class failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ DEBUGMSGTL(("sensors:arch:detail", "Name: %s, Class %s\n", ++ propname, propclass )); ++ ++ ++ /* ++ * Three classes represent further groups of sensors, etc. ++ * Call 'process_sensors' recursively to handle this next level ++ */ ++ if (( strstr( propclass, "picl" )) || ++ ( strstr( propclass, "frutree" )) || ++ ( strstr( propclass, "obp" ))) { ++ process_sensors( level, childh ); ++ } ++ /* ++ * Otherwise retrieve the value appropriately based on the ++ * class of the sensor. ++ * ++ * We need to specify the name of the PICL property to retrieve ++ * for this class of sensor, and the Net-SNMP sensor type. ++ */ ++ else if ( strstr( propclass, "fan-tachometer" )) { ++ process_num_sensor( childh, propname, "AtoDSensorValue", ++ NETSNMP_SENSOR_TYPE_RPM ); ++ } else if ( strstr( propclass, "fan" )) { ++ process_num_sensor( childh, propname, "Speed", ++ NETSNMP_SENSOR_TYPE_RPM ); ++ } else if ( strstr( propclass, "temperature-sensor" )) { ++ process_num_sensor( childh, propname, "Temperature", ++ NETSNMP_SENSOR_TYPE_TEMPERATURE ); ++ } else if ( strstr( propclass, "voltage-sensor" )) { ++ process_num_sensor( childh, propname, "Voltage", ++ /* ?? */ NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); ++ } else if ( strstr( propclass, "digital-sensor" )) { ++ process_num_sensor( childh, propname, "AtoDSensorValue", ++ /* ?? */ NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); ++ /* ++ * Enumeration-valued sensors use a fixed PICL property ("State"), ++ * but take a list of the values appropriate for that sensor, ++ * as well as the Net-SNMP sensor type. ++ */ ++ } else if ( strstr( propclass, "switch" )) { ++ process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_OTHER, ++ switch_settings ); ++ } else if ( strstr( propclass, "led" )) { ++ process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_OTHER, ++ led_settings ); ++ } else if ( strstr( propclass, "i2c" )) { ++ process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_BOOLEAN, /* ?? */ ++ i2c_settings ); ++ } else { ++ /* Skip other classes of sensor */ ++ DEBUGMSGTL(("sensors:arch:detail", "Skipping class %s\n", propclass )); ++ } ++ ++ /* ++ * Move on to the next child node at the current level (if any) ++ */ ++ error_code = pick_get_propval_by_name( childh, PICL_PROP_PEER, ++ &nexth, sizeof(nexth)); ++ if ( error_code != PICL_SUCCESS ) { ++ /* That's All Folks! */ ++ return (( error_code == PICL_PROPNOTFOUND ) ++ ? PICL_SUCCESS : error_code ); ++ } ++ childh = nexth; ++ } ++ ++ return error_code; ++} ++ ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ int error_code; ++ picl_nodehdl_t rooth; ++ ++ DEBUGMSGTL(("sensors:arch", "Reload PICLd Sensors module\n")); ++ ++ error_code = picl_get_root(&rooth); ++ if ( error_code != PICL_SUCCESS) { ++ DEBUGMSGTL(("sensors:arch", "Couldn't get root node (error %d)\n", error_code)); ++ return 1; ++ } ++ ++ error_code = process_sensors(0, rooth); ++ if ( error_code != 255 ) ++ if ( error_code != 7 ) /* ignore PICL_PROPNOTFOUND error */ ++ DEBUGMSGTL(("sensors:arch", "Internal PICLd problem (error %d)\n", error_code)); ++ ++ return 0; ++} ++ ++void netsnmp_sensor_arch_shutdown( void ) { ++ DEBUGMSGTL(("sensors:arch", "Shutdown PicLD Sensors module\n")); ++ picl_shutdown(); ++} ++ +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/hardware/sensors/picld_sensors.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/hardware/sensors/picld_sensors.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/ucd-snmp/lmsensorsMib.c +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/ucd-snmp/lmsensorsMib.c 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,205 @@ ++#include ++#include ++#include ++#include ++#include "ucd-snmp/lmsensorsMib.h" ++ ++netsnmp_container *sensorContainer = NULL; ++ ++void initialize_lmSensorsTable(const char *tableName, oid *tableOID, ++ netsnmp_container_op *filter, int mult ); ++ ++int _sensor_filter_temp( netsnmp_container *c, const void *v ); ++int _sensor_filter_fan( netsnmp_container *c, const void *v ); ++int _sensor_filter_volt( netsnmp_container *c, const void *v ); ++int _sensor_filter_misc( netsnmp_container *c, const void *v ); ++ ++static oid lmTempSensorsTable_oid[] = {1,3,6,1,4,1,2021,13,16,2}; ++static oid lmFanSensorsTable_oid[] = {1,3,6,1,4,1,2021,13,16,3}; ++static oid lmVoltSensorsTable_oid[] = {1,3,6,1,4,1,2021,13,16,4}; ++static oid lmMiscSensorsTable_oid[] = {1,3,6,1,4,1,2021,13,16,5}; ++ /* All the tables have the same length root OID */ ++size_t lmSensorsTables_oid_len = OID_LENGTH(lmMiscSensorsTable_oid); ++ ++ ++/* Initialise the LM Sensors MIB module */ ++void ++init_lmsensorsMib(void) ++{ ++ DEBUGMSGTL(("ucd-snmp/lmsensorsMib","Initializing LM-SENSORS-MIB tables\n")); ++ ++ /* ++ * Initialise the four LM-SENSORS-MIB tables ++ * ++ * They are almost identical, so we can use the same registration code. ++ */ ++ initialize_lmSensorsTable( "lmTempSensorsTable", lmTempSensorsTable_oid, ++ _sensor_filter_temp, 1000 ); /* MIB asks for mC */ ++ initialize_lmSensorsTable( "lmFanSensorsTable", lmFanSensorsTable_oid, ++ _sensor_filter_fan, 1); ++ initialize_lmSensorsTable( "lmVoltSensorsTable", lmVoltSensorsTable_oid, ++ _sensor_filter_volt, 1000 ); /* MIB asks for mV */ ++ initialize_lmSensorsTable( "lmMiscSensorsTable", lmMiscSensorsTable_oid, ++ _sensor_filter_misc, 1 ); ++} ++ ++/* ++ * Common initialisation code, used for setting up all four tables ++ */ ++void ++initialize_lmSensorsTable(const char *tableName, oid *tableOID, ++ netsnmp_container_op *filter, int mult ) ++{ ++ netsnmp_handler_registration *reg; ++ netsnmp_table_registration_info *table_info; ++ netsnmp_cache *cache; ++ netsnmp_container *container; ++ ++ /* ++ * Ensure the HAL sensors module has been initialised, ++ * and retrieve the main sensors container. ++ * This table will then be registered using a filter on this container. ++ */ ++ sensorContainer = get_sensor_container(); ++ if ( !sensorContainer ) { ++ init_hw_sensors( ); ++ sensorContainer = get_sensor_container(); ++ } ++ container = netsnmp_container_find("sensorTable:table_container"); ++ container->insert_filter = filter; ++ netsnmp_container_add_index( sensorContainer, container ); ++ ++ ++ /* ++ * Create a basic registration structure for the table ++ */ ++ reg = netsnmp_create_handler_registration( ++ tableName, lmSensorsTables_handler, ++ tableOID, lmSensorsTables_oid_len, HANDLER_CAN_RONLY ++ ); ++ ++ /* ++ * Register the table using the filtered container ++ * Include an indicator of any scaling to be applied to the sensor value ++ */ ++ reg->my_reg_void = (void *)mult; ++ table_info = SNMP_MALLOC_TYPEDEF( netsnmp_table_registration_info ); ++ netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, 0); ++ table_info->min_column = COLUMN_LMSENSORS_INDEX; ++ table_info->max_column = COLUMN_LMSENSORS_VALUE; ++ netsnmp_container_table_register( reg, table_info, container, 0 ); ++ ++ /* ++ * If the HAL sensors module was configured as an on-demand caching ++ * module (rather than being automatically loaded regularly), ++ * then ensure this table makes use of that cache. ++ */ ++ cache = get_sensor_cache(); ++ if ( cache ) { ++ netsnmp_inject_handler_before( reg, netsnmp_cache_handler_get( cache ), ++ "table_container"); ++ } ++ ++} ++ ++ ++/* ++ * Container filters for the four tables ++ * ++ * Used to ensure that sensor entries appear in the appropriate table. ++ */ ++int _sensor_filter_temp( netsnmp_container *c, const void *v ) { ++ const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v; ++ /* Only matches temperature sensors */ ++ return (( sp->type == NETSNMP_SENSOR_TYPE_TEMPERATURE ) ? 0 : 1 ); ++} ++ ++int _sensor_filter_fan( netsnmp_container *c, const void *v ) { ++ const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v; ++ /* Only matches fan sensors */ ++ return (( sp->type == NETSNMP_SENSOR_TYPE_RPM ) ? 0 : 1 ); ++} ++ ++int _sensor_filter_volt( netsnmp_container *c, const void *v ) { ++ const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v; ++ /* Only matches voltage sensors (AC or DC) */ ++ return ((( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_DC ) || ++ ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_AC )) ? 0 : 1 ); ++} ++ ++int _sensor_filter_misc( netsnmp_container *c, const void *v ) { ++ const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v; ++ /* Matches everything except temperature, fan or voltage sensors */ ++ return ((( sp->type == NETSNMP_SENSOR_TYPE_TEMPERATURE ) || ++ ( sp->type == NETSNMP_SENSOR_TYPE_RPM ) || ++ ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_DC ) || ++ ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_AC )) ? 1 : 0 ); ++} ++ ++ ++/* ++ * Handle requests for any of the four lmXxxxSensorsTables ++ * ++ * This is possible because all the table share the ++ * same structure and behaviour. ++ */ ++int ++lmSensorsTables_handler( ++ netsnmp_mib_handler *handler, ++ netsnmp_handler_registration *reginfo, ++ netsnmp_agent_request_info *reqinfo, ++ netsnmp_request_info *requests) { ++ ++ netsnmp_request_info *request; ++ netsnmp_table_request_info *table_info; ++ netsnmp_sensor_info *sensor_info; ++ int mult = (int)reginfo->my_reg_void; ++ ++ DEBUGMSGTL(( "ucd-snmp/lmsensorsMib","lmSensorsTables_handler - root: ")); ++ DEBUGMSGOID(("ucd-snmp/lmsensorsMib", reginfo->rootoid, reginfo->rootoid_len)); ++ DEBUGMSG(( "ucd-snmp/lmsensorsMib",", mode %d\n", reqinfo->mode )); ++ /* ++ * This is a read-only table, so we only need to handle GET requests. ++ * (The container helper converts GETNEXT->GET requests automatically). ++ */ ++ switch (reqinfo->mode) { ++ case MODE_GET: ++ for (request=requests; request; request=request->next) { ++ sensor_info = (netsnmp_sensor_info *) ++ netsnmp_container_table_extract_context(request); ++ if ( !sensor_info ) { ++ netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE); ++ continue; ++ } ++ ++ table_info = netsnmp_extract_table_info(request); ++ switch (table_info->colnum) { ++ case COLUMN_LMSENSORS_INDEX: ++ snmp_set_var_typed_integer( request->requestvb, ASN_INTEGER, ++ sensor_info->idx.oids[0]); ++ break; ++ case COLUMN_LMSENSORS_DEVICE: ++ if ( sensor_info->descr[0] != '\0' ) { ++ snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR, ++ sensor_info->descr, strlen(sensor_info->descr)); ++ } else { ++ snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR, ++ sensor_info->name, strlen(sensor_info->name)); ++ } ++ break; ++ case COLUMN_LMSENSORS_VALUE: ++ /* Multiply the value by the appropriate scaling factor for this table */ ++ snmp_set_var_typed_integer( request->requestvb, ASN_GAUGE, ++ (int)(mult*sensor_info->value)); ++ break; ++ default: ++ netsnmp_set_request_error(reqinfo, request, ++ SNMP_NOSUCHOBJECT); ++ break; ++ } ++ } ++ break; ++ ++ } ++ return SNMP_ERR_NOERROR; ++} +diff -up /dev/null net-snmp-5.4.1/agent/mibgroup/ucd-snmp/lmsensorsMib.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/agent/mibgroup/ucd-snmp/lmsensorsMib.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,23 @@ ++#ifndef LM_SENSORS_MIB_H ++#define LM_SENSORS_MIB_H ++ ++config_require(hardware/sensors) ++config_add_mib(LM-SENSORS-MIB) ++ ++/* function declarations */ ++void init_lmsensorsMib(void); ++ ++/* ++ * Handler and Column definitions for lmXxxxSensorsTable ++ * ++ * Note that the same handler (and hence the same ++ * column identifiers) are used for all four tables. ++ * This is possible because all the table share the ++ * same structure and behaviour. ++ */ ++Netsnmp_Node_Handler lmSensorsTables_handler; ++#define COLUMN_LMSENSORS_INDEX 1 ++#define COLUMN_LMSENSORS_DEVICE 2 ++#define COLUMN_LMSENSORS_VALUE 3 ++ ++#endif /* LM_SENSORS_MIB_H */ +diff -up net-snmp-5.4.1/configure.backup_patch_15 net-snmp-5.4.1/configure +--- net-snmp-5.4.1/configure.backup_patch_15 2008-07-25 12:53:39.000000000 +0200 ++++ net-snmp-5.4.1/configure 2008-07-25 12:53:46.000000000 +0200 +@@ -31030,7 +31030,7 @@ fi + fi + + # LM-SENSORS-MIB support +-echo " $module_list " | grep " ucd-snmp/lmSensors " > /dev/null ++echo " $module_list " | $GREP -i "ucd-snmp/lmsensor" > /dev/null + if test $? -eq 0 ; then + echo "$as_me:$LINENO: checking for sensors support" >&5 + echo $ECHO_N "checking for sensors support... $ECHO_C" >&6 +diff -up net-snmp-5.4.1/configure.in.backup_patch_15 net-snmp-5.4.1/configure.in +--- net-snmp-5.4.1/configure.in.backup_patch_15 2008-07-25 12:53:39.000000000 +0200 ++++ net-snmp-5.4.1/configure.in 2008-07-25 12:53:46.000000000 +0200 +@@ -2880,7 +2880,7 @@ if test $? -eq 0 ; then + fi + + # LM-SENSORS-MIB support +-echo " $module_list " | grep " ucd-snmp/lmSensors " > /dev/null ++echo " $module_list " | $GREP -i "ucd-snmp/lmsensor" > /dev/null + if test $? -eq 0 ; then + AC_MSG_CHECKING([for sensors support]) + case $target_os in +diff -up /dev/null net-snmp-5.4.1/include/net-snmp/agent/hardware/sensors.h +--- /dev/null 2008-07-23 14:59:56.660004489 +0200 ++++ net-snmp-5.4.1/include/net-snmp/agent/hardware/sensors.h 2008-07-25 12:53:46.000000000 +0200 +@@ -0,0 +1,48 @@ ++/* ++ * Hardware Abstraction Layer - Sensors module ++ * ++ * Public interface ++ */ ++ ++#define NETSNMP_SENSOR_TYPE_OTHER 1 ++#define NETSNMP_SENSOR_TYPE_VOLTAGE_AC 3 ++#define NETSNMP_SENSOR_TYPE_VOLTAGE_DC 4 ++#define NETSNMP_SENSOR_TYPE_CURRENT 5 ++#define NETSNMP_SENSOR_TYPE_POWER 6 ++#define NETSNMP_SENSOR_TYPE_FREQUENCY 7 ++#define NETSNMP_SENSOR_TYPE_TEMPERATURE 8 ++#define NETSNMP_SENSOR_TYPE_HUMIDITY 9 ++#define NETSNMP_SENSOR_TYPE_RPM 10 ++#define NETSNMP_SENSOR_TYPE_VOLUME 11 ++#define NETSNMP_SENSOR_TYPE_BOOLEAN 12 ++ ++ ++#define NETSNMP_SENSOR_FLAG_ACTIVE 0x01 ++#define NETSNMP_SENSOR_FLAG_NAVAIL 0x02 ++#define NETSNMP_SENSOR_FLAG_BROKEN 0x04 ++#define NETSNMP_SENSOR_FLAG_DISABLE 0x08 ++ ++#define NETSNMP_SENSOR_MASK_STATUS 0x06 /* NAVAIL|BROKEN */ ++ ++ ++#define NETSNMP_SENSOR_FIND_CREATE 1 /* or use one of the sensor type values */ ++#define NETSNMP_SENSOR_FIND_EXIST 0 ++ ++typedef struct netsnmp_sensor_info_s netsnmp_sensor_info; ++struct netsnmp_sensor_info_s { ++ ++ netsnmp_index idx; ++ /* int idx; */ ++ char name[256]; ++ ++ int type; ++ float value; ++ char descr[256]; ++ long flags; ++}; ++ ++netsnmp_container *get_sensor_container( void ); ++netsnmp_cache *get_sensor_cache( void ); ++netsnmp_sensor_info *sensor_by_name( char *, int ); ++NetsnmpCacheLoad netsnmp_sensor_load; ++NetsnmpCacheFree netsnmp_sensor_free; diff --git a/net-analyzer/net-snmp/files/snmpd.init b/net-analyzer/net-snmp/files/snmpd.init new file mode 100644 index 00000000..d8419eaa --- /dev/null +++ b/net-analyzer/net-snmp/files/snmpd.init @@ -0,0 +1,47 @@ +#!/sbin/runscript +# Copyright 1999-2009 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/net-analyzer/net-snmp/files/snmpd.init,v 1.1 2009/10/16 08:51:05 gengor Exp $ + +opts="${opts} reload" + +depend() { + use logger + need net +} + +SNMPD_PIDFILE="${SNMPD_PIDFILE:-/var/run/snmpd.pid}" + +checkconfig() { + if [ ! -e /etc/snmp/snmpd.conf ] ; then + eerror "${SVCNAME} requires an /etc/snmp/snmpd.conf configuration file" + return 1 + fi +} + +start() { + checkconfig || return 1 + ebegin "Starting ${SVCNAME}" + start-stop-daemon --start --quiet --exec /usr/sbin/snmpd \ + -- -p ${SNMPD_PIDFILE} ${SNMPD_FLAGS} + eend $? +} + +stop() { + ebegin "Stopping ${SVCNAME}" + start-stop-daemon --stop --quiet --pidfile ${SNMPD_PIDFILE} + eend $? +} + +reload() { + checkconfig || return 1 + if [ ! -f ${SNMPD_PIDFILE} ]; then + eerror "Cannot reload configuration, ${SVCNAME} is not running" + eend 1 + return 1 + fi + + ebegin "Reloading ${SVCNAME} configuration" + kill -HUP $(< ${SNMPD_PIDFILE}) &>/dev/null + eend $? +} diff --git a/net-analyzer/net-snmp/files/snmptrapd.init b/net-analyzer/net-snmp/files/snmptrapd.init new file mode 100644 index 00000000..7a311f95 --- /dev/null +++ b/net-analyzer/net-snmp/files/snmptrapd.init @@ -0,0 +1,24 @@ +#!/sbin/runscript +# Copyright 1999-2009 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/net-analyzer/net-snmp/files/snmptrapd.init,v 1.1 2009/10/16 08:51:05 gengor Exp $ + +depend() { + use logger + need net +} + +SNMPTRAPD_PIDFILE="${SNMPTRAPD_PIDFILE:-/var/run/snmptrapd.pid}" + +start() { + ebegin "Starting ${SVCNAME}" + start-stop-daemon --start --quiet --exec /usr/sbin/snmptrapd \ + -- -p ${SNMPTRAPD_PIDFILE} ${SNMPTRAPD_FLAGS} + eend $? +} + +stop() { + ebegin "Stopping ${SVCNAME}" + start-stop-daemon --stop --quiet --pidfile ${SNMPTRAPD_PIDFILE} + eend $? +} diff --git a/net-analyzer/net-snmp/net-snmp-5.4.2.1-r2.ebuild b/net-analyzer/net-snmp/net-snmp-5.4.2.1-r2.ebuild new file mode 100644 index 00000000..118dfd76 --- /dev/null +++ b/net-analyzer/net-snmp/net-snmp-5.4.2.1-r2.ebuild @@ -0,0 +1,197 @@ +# Copyright 1999-2009 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/net-analyzer/net-snmp/net-snmp-5.4.2.1-r2.ebuild,v 1.1 2009/10/16 08:51:06 gengor Exp $ + +EAPI=2 + +inherit fixheadtails flag-o-matic perl-module python autotools + +DESCRIPTION="Software for generating and retrieving SNMP data" +HOMEPAGE="http://net-snmp.sourceforge.net/" +SRC_URI="mirror://sourceforge/${PN}/${P}.tar.gz" + +LICENSE="as-is BSD" +SLOT="0" +KEYWORDS="~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86" +IUSE="bzip2 diskio doc elf extensible ipv6 kernel_linux lm_sensors mfd-rewrites minimal perl python rpm selinux sendmail smux ssl tcpd X zlib" + +COMMON="ssl? ( >=dev-libs/openssl-0.9.6d ) + tcpd? ( >=sys-apps/tcp-wrappers-7.6 ) + rpm? ( + app-arch/rpm + dev-libs/popt + app-arch/bzip2 + >=sys-libs/zlib-1.1.4 + ) + bzip2? ( app-arch/bzip2 ) + zlib? ( >=sys-libs/zlib-1.1.4 ) + elf? ( dev-libs/elfutils ) + lm_sensors? ( + kernel_linux? ( sys-apps/lm_sensors ) + ) + python? ( dev-python/setuptools )" + +RDEPEND="${COMMON} + perl? ( + X? ( dev-perl/perl-tk ) + !minimal? ( dev-perl/TermReadKey ) + ) + selinux? ( sec-policy/selinux-snmpd )" + +# Dependency on autoconf due to bug #225893 +DEPEND="${COMMON} + >=sys-devel/autoconf-2.61-r2 + >=sys-apps/sed-4 + doc? ( app-doc/doxygen )" + +src_prepare() { + # Fix CVE-2008-6123 + epatch "${FILESDIR}"/CVE-2008-6123.patch + + # lm_sensors-3 support + if use lm_sensors ; then + epatch "${FILESDIR}"/${PN}-5.4.1-sensors3.patch \ + "${FILESDIR}"/${PN}-5.4.1-sensors3-version_detect.patch + fi + + # fix access violation in make check + sed -i -e 's/\(snmpd.*\)-Lf/\1-l/' testing/eval_tools.sh || \ + die "sed eval_tools.sh failed" + # fix path in fixproc + sed -i -e 's|\(database_file =.*\)/local\(.*\)$|\1\2|' local/fixproc || \ + die "sed fixproc failed" + + if use python ; then + python_version + PYTHON_MODNAME="netsnmp" + PYTHON_DIR="/usr/$(get_libdir)/python${PYVER}/site-packages" + sed -i -e "s:\(install --basedir=\$\$dir\):\1 --root='${D}':" Makefile.in || \ + die "sed python failed" + fi + + # snmpconf generates config files with proper selinux context + use selinux && epatch "${FILESDIR}"/${PN}-5.1.2-snmpconf-selinux.patch + + use rpm && epatch "${FILESDIR}"/${PN}-5.4.1.1-rpm5-1.patch #202399 + + # Fix version number: + sed -i -e "s:NetSnmpVersionInfo = \".*\":NetSnmpVersionInfo = \"${PV}\":" snmplib/snmp_version.c + + eautoreconf + + ht_fix_all +} + +src_configure() { + strip-flags + + local mibs="host ucd-snmp/dlmod" + use diskio && mibs="${mibs} ucd-snmp/diskio" + use extensible && mibs="${mibs} ucd-snmp/extensible" + use lm_sensors && mibs="${mibs} ucd-snmp/lmsensorsMib" + use sendmail && mibs="${mibs} mibII/mta_sendmail" + use smux && mibs="${mibs} smux" + + local myconf="$(use_enable ipv6) \ + $(use_enable mfd-rewrites) \ + $(use_enable perl embedded-perl) \ + $(use_enable !ssl internal-md5) \ + $(use_with elf) \ + $(use_with perl perl-modules) \ + $(use_with python python-modules) \ + $(use_with ssl openssl) \ + $(use_with tcpd libwrap)" + if use rpm ; then + myconf="${myconf} \ + --with-rpm \ + --with-bzip2 \ + --with-zlib" + else + myconf="${myconf} \ + $(use_with bzip2) \ + $(use_with zlib)" + fi + + econf \ + --with-install-prefix="${D}" \ + --with-sys-location="Unknown" \ + --with-sys-contact="root@Unknown" \ + --with-default-snmp-version="3" \ + --with-mib-modules="${mibs}" \ + --with-logfile="/var/log/net-snmpd.log" \ + --with-persistent-directory="/var/lib/net-snmp" \ + --enable-ucd-snmp-compatibility \ + --enable-shared \ + --enable-as-needed \ + ${myconf} +} + +src_compile() { + emake -j1 || die "emake failed" + + if use doc ; then + einfo "Building HTML Documentation" + make docsdox || die "failed to build docs" + fi +} + +src_test() { + cd testing + if ! make test ; then + echo + einfo "Don't be alarmed if a few tests FAIL." + einfo "This could happen for several reasons:" + einfo " - You don't already have a working configuration." + einfo " - Your ethernet interface isn't properly configured." + echo + fi +} + +src_install () { + make DESTDIR="${D}" install || die "make install failed" + + if use perl ; then + fixlocalpod + use X || rm -f "${D}"/usr/bin/tkmib + else + rm -f "${D}"/usr/bin/mib2c "${D}"/usr/bin/snmpcheck "${D}"/usr/bin/tkmib + fi + + dodoc AGENT.txt ChangeLog FAQ INSTALL NEWS PORTING README* TODO || die + newdoc EXAMPLE.conf.def EXAMPLE.conf || die + + use doc && { dohtml docs/html/* || die ; } + + keepdir /etc/snmp /var/lib/net-snmp + + newinitd "${FILESDIR}"/snmpd.init snmpd || die + newconfd "${FILESDIR}"/snmpd.conf snmpd || die + + newinitd "${FILESDIR}"/snmptrapd.init snmptrapd || die + newconfd "${FILESDIR}"/snmptrapd.conf snmptrapd || die + + # Remove everything not required for an agent. + # Keep only the snmpd, snmptrapd, MIBs, headers and libraries. + if use minimal; then + elog "USE='minimal' is set. Removing excess/non-minimal components." + rm -rf + "${D}"/usr/bin/{encode_keychange,snmp{get,getnext,set,usm,walk,bulkwalk,table,trap,bulkget,translate,status,delta,test,df,vacm,netstat,inform,snmpcheck}} + rm -rf "${D}"/usr/share/snmp/snmpconf-data "${D}"/usr/share/snmp/*.conf + rm -rf "${D}"/usr/bin/{fixproc,traptoemail} "${D}"/usr/bin/snmpc{heck,onf} + find "${D}" -name '*.pl' -exec rm -f '{}' \; + use ipv6 || rm -rf "${D}"/usr/share/snmp/mibs/IPV6* + fi + + # bug 113788, install example config + insinto /etc/snmp + newins "${S}"/EXAMPLE.conf snmpd.conf.example || die +} + +pkg_postrm() { + use python && python_mod_cleanup +} + +pkg_postinst() { + elog "An example configuration file has been installed in" + elog "/etc/snmp/snmpd.conf.example." +}