开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
lmSensors.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：32k
源码类别：

SNMP编程

开发平台：

Unix_Linux

lmSensors.c：源码内容
  1. /* lmSensors.c
  2.  *
  3.  * Sections of this code were derived from the published API's of 
  4.  * some Sun products.  Hence, portions of the code may be copyright
  5.  * Sun Microsystems.
  6.  *
  7.  * This component allows net-snmp to report sensor information.
  8.  *
  9.  * In order to use it, the ./configure invocation must include...
  10.  *
  11.  * --with-mib-modules="ucd-snmp/lmSensors"
  12.  *
  13.  * It uses one of three different methodologies.  Some platforms make
  14.  * use of an lm_sensors driver to access the information on the
  15.  * health monitoring hardware, such as the LM75 and LM78 chips.
  16.  *
  17.  * For further information see http://secure.netroedge.com/~lm78/
  18.  *
  19.  * The Solaris platform uses the other two methodologies.  Earlier
  20.  * platforms such as the Enterprise 450 use kstat to report sensor
  21.  * information.  Later platforms, such as the V880 use the picld
  22.  * daemon to control system resources and report sensor information.
  23.  * Picld is supported only on Solaris 2.8 and later.
  24.  * 
  25.  * KSTAT
  26.  *
  27.  * The code initializes the kstat variables, then does a specific inquiry
  28.  * for what we're looking for.
  29.  *
  30.  * PICLD
  31.  *
  32.  * If picld is available on the platform, it tries to initialize picld.
  33.  * If that works, it points itself to the top of the picld btree
  34.  * and walks it way down recursively looking for sensors and child leafs.
  35.  * If it finds a child, it goes in and works it way down recursively.
  36.  * If it finds a sensor, it deals with it.
  37.  *
  38.  * Both these methodologies are implemented in a "read only" manner.
  39.  * You cannot use this code to change anything eg. fan speeds.
  40.  *
  41.  * The lmSensors component delivers the information documented in the
  42.  * LM-SENSORS-MIB.  The information is divided up as follows:
  43.  *
  44.  * -temperatures (Celsius)
  45.  * -fans (rpm's)
  46.  * -voltages
  47.  * -other (switches, LEDs and  i2c's (things that use the i2c bus))
  48.  * NOTE: This version does not support gpio's.  Still on the learning curve.
  49.  *
  50.  * Because the MIB only allows output of the datatype Gauge32 this
  51.  * limits the amount of meaningful information that can be delivered
  52.  * from "other" sensors.  Hence, the code does a certain amount of
  53.  * translating.  See the source for individual sensor types.
  54.  *
  55.  * If an "other" sensor delivers a value 99, it means that it
  56.  * is delivering a "status" that the code does not account for.
  57.  * If you discover one of these, please pass it on and I'll
  58.  * put it in.
  59.  *
  60.  * To see these messages, run the daemon as follows:
  61.  * 
  62.  * /usr/local/sbin/snmpd -f -L -Ducd-snmp/lmSensors
  63.  *
  64.  * or using gdb:
  65.  *
  66.  * gdb snmpd
  67.  * run -f -L -Ducd-snmp/lmSensors
  68.  *
  69.  * The component can record up to 256 instances of each type.
  70.  *
  71.  * The following should always be included first before anything else 
  72.  */
  74. #include <net-snmp/net-snmp-config.h>
  75. #include <net-snmp/net-snmp-includes.h>
  76. #include <net-snmp/agent/net-snmp-agent-includes.h>
  78. /*
  79.  * minimal include directives 
  80.  */
  82. #include "util_funcs.h"
  83. #include <time.h>
  85. /*
  86.  * Load required drivers and libraries.
  87.  */
  89. #ifdef solaris2
  90.     #include <kstat.h>
  91.     #ifdef HAVE_PICL_H 
  92.         #include <picl.h> /* accesses the picld daemon */
  93.     #endif 
  94.     #include </usr/platform/sun4u/include/sys/envctrl.h> /*should this be more generic? */
  95. #else
  96.     #include <sensors/sensors.h>
  97.     #define CONFIG_FILE_NAME "/etc/sensors.conf"
  98. #endif
  100. #include "lmSensors.h"
  102. #define N_TYPES      (4)
  104. #ifdef solaris2
  105.     #define MAX_NAME     (256)
  106.     #define MAX_SENSORS  (256) /* there's a lot of sensors on a v880 */
  107. #else
  108.     #define MAX_NAME     (64)
  109.     #define MAX_SENSORS  (128)
  110. #endif
  113. /*
  114.  * lmSensors_variables_oid:
  115.  *   this is the top level oid that we want to register under.  This
  116.  *   is essentially a prefix, with the suffix appearing in the
  117.  *   variable below.
  118.  */
  121. oid             lmSensors_variables_oid[] =
  122.     { 1, 3, 6, 1, 4, 1, 2021, 13, 16 };
  124. /*
  125.  * variable4 lmSensors_variables:
  126.  *   this variable defines function callbacks and type return information 
  127.  *   for the lmSensors mib section 
  128.  */
  130. struct variable4 lmSensors_variables[] = {
  131.     /*
  132.      * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix 
  133.      */
  134. #define   LMTEMPSENSORSINDEX    3
  135.     {LMTEMPSENSORSINDEX, ASN_INTEGER, RONLY, var_lmSensorsTable, 3,
  136.      {2, 1, 1}},
  137. #define   LMTEMPSENSORSDEVICE   4
  138.     {LMTEMPSENSORSDEVICE, ASN_OCTET_STR, RONLY, var_lmSensorsTable, 3,
  139.      {2, 1, 2}},
  140. #define   LMTEMPSENSORSVALUE    5
  141.     {LMTEMPSENSORSVALUE, ASN_GAUGE, RONLY, var_lmSensorsTable, 3,
  142.      {2, 1, 3}},
  143. #define   LMFANSENSORSINDEX     8
  144.     {LMFANSENSORSINDEX, ASN_INTEGER, RONLY, var_lmSensorsTable, 3,
  145.      {3, 1, 1}},
  146. #define   LMFANSENSORSDEVICE    9
  147.     {LMFANSENSORSDEVICE, ASN_OCTET_STR, RONLY, var_lmSensorsTable, 3,
  148.      {3, 1, 2}},
  149. #define   LMFANSENSORSVALUE     10
  150.     {LMFANSENSORSVALUE, ASN_GAUGE, RONLY, var_lmSensorsTable, 3,
  151.      {3, 1, 3}},
  152. #define   LMVOLTSENSORSINDEX    13
  153.     {LMVOLTSENSORSINDEX, ASN_INTEGER, RONLY, var_lmSensorsTable, 3,
  154.      {4, 1, 1}},
  155. #define   LMVOLTSENSORSDEVICE   14
  156.     {LMVOLTSENSORSDEVICE, ASN_OCTET_STR, RONLY, var_lmSensorsTable, 3,
  157.      {4, 1, 2}},
  158. #define   LMVOLTSENSORSVALUE    15
  159.     {LMVOLTSENSORSVALUE, ASN_GAUGE, RONLY, var_lmSensorsTable, 3,
  160.      {4, 1, 3}},
  161. #define   LMMISCSENSORSINDEX    18
  162.     {LMMISCSENSORSINDEX, ASN_INTEGER, RONLY, var_lmSensorsTable, 3,
  163.      {5, 1, 1}},
  164. #define   LMMISCSENSORSDEVICE   19
  165.     {LMMISCSENSORSDEVICE, ASN_OCTET_STR, RONLY, var_lmSensorsTable, 3,
  166.      {5, 1, 2}},
  167. #define   LMMISCSENSORSVALUE    20
  168.     {LMMISCSENSORSVALUE, ASN_GAUGE, RONLY, var_lmSensorsTable, 3,
  169.      {5, 1, 3}},
  170. };
  172. typedef struct {
  173. #ifdef solaris2
  174.     #ifdef HAVE_PICL_H
  175.         char            name[PICL_PROPNAMELEN_MAX]; /*required for picld*/
  176.         int             value;
  177.     #else
  178.        char            name[MAX_NAME];
  179.        int             value;
  180.     #endif
  181. #else
  182.     char            name[MAX_NAME];
  183.     int             value;
  184. #endif
  185. } _sensor;
  187. typedef struct {
  188.     int             n;
  189.     _sensor         sensor[MAX_SENSORS];
  190. } _sensor_array;
  192. static _sensor_array sensor_array[N_TYPES];
  193. static clock_t  timestamp;
  195. static int      sensor_init(void);
  196. static void     sensor_load(void);
  197. static void     _sensor_load(clock_t t);
  200. /*
  201.  * init_lmSensors():
  202.  *   Initialization routine.  This is called when the agent starts up.
  203.  *   At a minimum, registration of your variables should take place here.
  204.  */
  205. void
  206. init_lmSensors(void)
  207. {
  208.    sensor_init(); 
  210.     /*
  211.      * register ourselves with the agent to handle our mib tree 
  212.      */
  213.     REGISTER_MIB("lmSensors", lmSensors_variables, variable4,
  214.                  lmSensors_variables_oid);
  215. }
  217. /*
  218.  * var_lmSensorsTable():
  219.  *   Handle this table separately from the scalar value case.
  220.  *   The workings of this are basically the same as for var_lmSensors above.
  221.  */
  222. unsigned char  *
  223. var_lmSensorsTable(struct variable *vp,
  224.                    oid * name,
  225.                    size_t * length,
  226.                    int exact,
  227.                    size_t * var_len, WriteMethod ** write_method)
  228. {
  229.     static long     long_ret;
  230.     static unsigned char string[SPRINT_MAX_LEN];
  232.     int             s_index;
  233.     int             s_type = -1;
  234.     int             n_sensors;
  236.     _sensor         s;
  238.     sensor_load();
  240.     switch (vp->magic) {
  241.     case LMTEMPSENSORSINDEX:
  242.     case LMTEMPSENSORSDEVICE:
  243.     case LMTEMPSENSORSVALUE:
  244.         s_type = 0;
  245.         n_sensors = sensor_array[0].n;
  246.         break;
  248.     case LMFANSENSORSINDEX:
  249.     case LMFANSENSORSDEVICE:
  250.     case LMFANSENSORSVALUE:
  251.         s_type = 1;
  252.         n_sensors = sensor_array[1].n;
  253.         break;
  255.     case LMVOLTSENSORSINDEX:
  256.     case LMVOLTSENSORSDEVICE:
  257.     case LMVOLTSENSORSVALUE:
  258.         s_type = 2;
  259.         n_sensors = sensor_array[2].n;
  260.         break;
  262.     case LMMISCSENSORSINDEX:
  263.     case LMMISCSENSORSDEVICE:
  264.     case LMMISCSENSORSVALUE:
  265.         s_type = 3;
  266.         n_sensors = sensor_array[3].n;
  267.         break;
  269.     default:
  270.         s_type = -1;
  271.         n_sensors = 0;
  272.     }
  274.     if (header_simple_table(vp, name, length, exact,
  275.                             var_len, write_method,
  276.                             n_sensors) == MATCH_FAILED)
  277.         return NULL;
  279.     if (s_type < 0)
  280.         return NULL;
  282.     s_index = name[*length - 1] - 1;
  283.     s = sensor_array[s_type].sensor[s_index];
  285.     switch (vp->magic) {
  286.     case LMTEMPSENSORSINDEX:
  287.     case LMFANSENSORSINDEX:
  288.     case LMVOLTSENSORSINDEX:
  289.     case LMMISCSENSORSINDEX:
  290.         long_ret = s_index;
  291.         return (unsigned char *) &long_ret;
  293.     case LMTEMPSENSORSDEVICE:
  294.     case LMFANSENSORSDEVICE:
  295.     case LMVOLTSENSORSDEVICE:
  296.     case LMMISCSENSORSDEVICE:
  297.         strncpy(string, s.name, SPRINT_MAX_LEN - 1);
  298.         *var_len = strlen(string);
  299.         return (unsigned char *) string;
  301.     case LMTEMPSENSORSVALUE:
  302.     case LMFANSENSORSVALUE:
  303.     case LMVOLTSENSORSVALUE:
  304.     case LMMISCSENSORSVALUE:
  305.         long_ret = s.value;
  306.         return (unsigned char *) &long_ret;
  308.     default:
  309.         ERROR_MSG("Unable to handle table request");
  310.     }
  312.     return NULL;
  313. }
  315. static int
  316. sensor_init(void)
  317. {
  318. #ifndef solaris2
  319.     int             res;
  320.     char            filename[] = CONFIG_FILE_NAME;
  321.     clock_t         t = clock();
  322.     FILE           *fp = fopen(filename, "r");
  323.     if (!fp)
  324.         return 1;
  326.     if ((res = sensors_init(fp)))
  327.         return 2;
  329.     _sensor_load(t); /* I'll let the linux people decide whether they want to load right away */
  330. #endif
  331.     return 0;
  332. }
  334. static void
  335. sensor_load(void)
  336. {
  337. #ifdef solaris2
  338.     clock_t         t = time(NULL);
  339. #else
  340.     clock_t t = clock();
  341. #endif
  343.     if (t > timestamp + 6) /* this may require some tuning - currently 6 seconds*/
  344.         _sensor_load(t);
  346.     return;
  347. }
  349. /* This next code block includes all kstat and picld code for the Solaris platform.
  350.  * If you're not compiling on a Solaris that supports picld, it won't be included.
  351.  */
  353. #ifdef solaris2
  354. /* *******  picld sensor procedures * */
  355. #ifdef HAVE_PICL_H
  357. static void
  358. process_individual_fan(picl_nodehdl_t childh, 
  359.                      char propname[PICL_PROPNAMELEN_MAX])
  360. {
  361.     picl_nodehdl_t  sensorh;
  362.     picl_propinfo_t sensor_info;
  364.     int speed;
  365.     int typ = 1; /*fan*/
  367.     picl_errno_t    error_code,ec2;
  369.     if (sensor_array[typ].n >= MAX_SENSORS){
  370.         snmp_log(LOG_ERR, "There are too many sensors of type %dn",typ);
  371.         }
  372.     else{
  373.         error_code = (picl_get_propinfo_by_name(childh,
  374.                          "AtoDSensorValue",&sensor_info,&sensorh));
  375.         if (error_code == PICL_SUCCESS) {
  376.              ec2 = picl_get_propval(sensorh,&speed,sizeof(speed));
  377.              if (ec2 == PICL_SUCCESS){
  378.                  sensor_array[typ].sensor[sensor_array[typ].n].value = speed;
  379.                  snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
  380.                      (PICL_PROPNAMELEN_MAX - 1),"%s",propname);
  381.                  sensor_array[typ].sensor[sensor_array[typ].n].
  382.                      name[PICL_PROPNAMELEN_MAX - 1] = '';
  383.                  sensor_array[typ].n++;
  384.                  } /*end if ec2*/
  385.              else
  386.                  DEBUGMSGTL(("ucd-snmp/lmSensors", 
  387.                      "sensor value read error code->%dn",ec2));
  388.             } /* end if */
  389.         else
  390.             DEBUGMSGTL(("ucd-snmp/lmSensors", 
  391.                 "sensor lookup failed  error code->%dn",error_code));
  392.         }
  393. } /*process individual fan*/
  395. static void
  396. process_temperature_sensor(picl_nodehdl_t childh,
  397.                                char propname[PICL_PROPNAMELEN_MAX])
  398. {
  399.     picl_nodehdl_t  sensorh;
  400.     picl_propinfo_t sensor_info;
  402.     int temp;
  403.     int typ = 0; /*temperature*/
  405.     picl_errno_t    error_code,ec2;
  407.     if (sensor_array[typ].n >= MAX_SENSORS){
  408.         snmp_log(LOG_ERR, "There are too many sensors of type %dn",typ);
  409.         }
  410.     else{
  411.         error_code = (picl_get_propinfo_by_name(childh,
  412.                          "Temperature",&sensor_info,&sensorh));
  413.         if (error_code == PICL_SUCCESS) {
  414.              ec2 = picl_get_propval(sensorh,&temp,sizeof(temp));
  415.              if (ec2 == PICL_SUCCESS){
  416.                  sensor_array[typ].sensor[sensor_array[typ].n].value = temp;
  417.                  snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
  418.                      (PICL_PROPNAMELEN_MAX - 1),"%s",propname);
  419.                  sensor_array[typ].sensor[sensor_array[typ].n].
  420.                      name[PICL_PROPNAMELEN_MAX - 1] = '';
  421.                  sensor_array[typ].n++;
  422.                  } /*end if ec2*/
  423.              else
  424.                  DEBUGMSGTL(("ucd-snmp/lmSensors", 
  425.                                "sensor value read error code->%dn",ec2));
  426.             } /* end if */
  427.         else
  428.             DEBUGMSGTL(("ucd-snmp/lmSensors", 
  429.                 "sensor lookup failed  error code->%dn",error_code));
  430.         }
  431. }  /* process temperature sensor */
  433. static void
  434. process_digital_sensor(picl_nodehdl_t childh,
  435.                    char propname[PICL_PROPNAMELEN_MAX])
  436. {
  437.     picl_nodehdl_t  sensorh;
  438.     picl_propinfo_t sensor_info;
  440.     int temp; /*volts?*/
  441.     int typ = 2; /*volts*/
  443.     picl_errno_t    error_code,ec2;
  445.     if (sensor_array[typ].n >= MAX_SENSORS){
  446.         snmp_log(LOG_ERR, "There are too many sensors of type %dn",typ);
  447.         }
  448.     else{
  449.         error_code = (picl_get_propinfo_by_name(childh,
  450.                           "AtoDSensorValue",&sensor_info,&sensorh));
  451.         if (error_code == PICL_SUCCESS) {
  452.              ec2 = picl_get_propval(sensorh,&temp,sizeof(temp));
  453.              if (ec2 == PICL_SUCCESS){
  454.                  sensor_array[typ].sensor[sensor_array[typ].n].value = temp;
  455.                  snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
  456.                     (PICL_PROPNAMELEN_MAX - 1),"%s",propname);
  457.                  sensor_array[typ].sensor[sensor_array[typ].n].
  458.                       name[PICL_PROPNAMELEN_MAX - 1] = '';
  459.                  sensor_array[typ].n++;
  460.                  }
  461.              else
  462.                  DEBUGMSGTL(("ucd-snmp/lmSensors", 
  463.                    "sensor value read error code->%dn",ec2));
  464.             } /* end if */
  465.         else
  466.             DEBUGMSGTL(("ucd-snmp/lmSensors", 
  467.               "sensor lookup failed  error code->%dn",error_code));
  468.         }
  469. }  /* process digital sensor */
  471. static void
  472. process_switch(picl_nodehdl_t childh,
  473.                    char propname[PICL_PROPNAMELEN_MAX])
  474. {
  475.     picl_nodehdl_t  sensorh;
  476.     picl_propinfo_t sensor_info;
  478.     char state[32];
  479.     int st_cnt;
  480.     const char *switch_settings[]={"OFF","ON","NORMAL","LOCKED","UNKNOWN",
  481.                                     "DIAG","SECURE"};
  482.     u_int value;
  483.     u_int found = 0;
  484.     int max_key_posns = 7;
  485.     int typ = 3; /*other*/
  487.     if (sensor_array[typ].n >= MAX_SENSORS){
  488.         snmp_log(LOG_ERR, "There are too many sensors of type %dn",typ);
  489.         }
  490.     else{
  491.         picl_errno_t    error_code,ec2;
  493.         error_code = (picl_get_propinfo_by_name(childh,
  494.                          "State",&sensor_info,&sensorh));
  495.         if (error_code == PICL_SUCCESS) {
  496.              ec2 = picl_get_propval(sensorh,&state,sensor_info.size);
  497.              if (ec2 == PICL_SUCCESS){
  498.                  for (st_cnt=0;st_cnt < max_key_posns;st_cnt++){
  499.                      if (strncmp(state,switch_settings[st_cnt],
  500.                            strlen(switch_settings[st_cnt])) == 0){
  501.                          value = st_cnt;
  502.                          found = 1;
  503.                          break;
  504.                          } /* end if */
  505.                      } /* end for */
  506.                  if (found==0)
  507.                      value = 99;
  508.                  sensor_array[typ].sensor[sensor_array[typ].n].value = value;
  509.                  snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
  510.                      (PICL_PROPNAMELEN_MAX - 1),"%s",propname);
  511.                  sensor_array[typ].sensor[sensor_array[typ].n].
  512.                      name[PICL_PROPNAMELEN_MAX - 1] = '';
  513.                  sensor_array[typ].n++;
  514.                  } /*end if ec2*/
  515.              else
  516.                  DEBUGMSGTL(("ucd-snmp/lmSensors",
  517.                      "sensor value read error code->%dn",ec2));
  518.             } /* end if */
  519.         else
  520.             DEBUGMSGTL(("ucd-snmp/lmSensors",
  521.                 "sensor lookup failed  error code->%dn",error_code));
  522.         }
  523. } /*process switch*/
  525. static void
  526. process_led(picl_nodehdl_t childh,
  527.                    char propname[PICL_PROPNAMELEN_MAX])
  528. {
  529.     picl_nodehdl_t  sensorh;
  530.     picl_propinfo_t sensor_info;
  532.     char state[32];
  533.     int st_cnt;
  534.     const char *led_settings[]={"OFF","ON","BLINK"};
  535.     u_int value;
  536.     u_int found = 0;
  537.     int max_led_posns = 3;
  538.     int typ = 3; 
  540.     picl_errno_t    error_code,ec2;
  542.     if (sensor_array[typ].n >= MAX_SENSORS){
  543.         snmp_log(LOG_ERR, "There are too many sensors of type %dn",typ);
  544.         }
  545.     else{
  546.         error_code = (picl_get_propinfo_by_name(childh,
  547.                          "State",&sensor_info,&sensorh));
  548.         if (error_code == PICL_SUCCESS) {
  549.              ec2 = picl_get_propval(sensorh,&state,sensor_info.size);
  550.              if (ec2 == PICL_SUCCESS){
  551.                  for (st_cnt=0; st_cnt < max_led_posns; st_cnt++){
  552.                      if (strncmp(state,led_settings[st_cnt],
  553.                            strlen(led_settings[st_cnt])) == 0){
  554.                          value=st_cnt;
  555.                          found = 1;
  556.                          break;
  557.                          } 
  558.                      } 
  559.                  if (found==0)
  560.                      value = 99;
  561.                  sensor_array[typ].sensor[sensor_array[typ].n].value = value;
  562.                  snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
  563.                      (PICL_PROPNAMELEN_MAX - 1),"%s",propname);
  564.                  sensor_array[typ].sensor[sensor_array[typ].n].
  565.                      name[PICL_PROPNAMELEN_MAX - 1] = '';
  566.                  sensor_array[typ].n++;
  567.                  }
  568.              else
  569.                  DEBUGMSGTL(("ucd-snmp/lmSensors",
  570.                      "sensor value read error code->%dn",ec2));
  571.             } 
  572.         else
  573.             DEBUGMSGTL(("ucd-snmp/lmSensors",
  574.                 "sensor lookup failed  error code->%dn",error_code));
  575.        }
  576. } 
  578. static void
  579. process_i2c(picl_nodehdl_t childh,
  580.                    char propname[PICL_PROPNAMELEN_MAX])
  581. {
  582.     picl_nodehdl_t  sensorh;
  583.     picl_propinfo_t sensor_info;
  585.     char state[32];
  586.     int st_cnt;
  587.     const char *i2c_settings[]={"OK"};
  588.     u_int value;
  589.     u_int found = 0;
  590.     int max_i2c_posns = 1;
  591.     int typ = 3; 
  593.     picl_errno_t    error_code,ec2;
  595.     if (sensor_array[typ].n >= MAX_SENSORS){
  596.         snmp_log(LOG_ERR, "There are too many sensors of type %dn",typ);
  597.         }
  598.     else{
  599.         error_code = (picl_get_propinfo_by_name(childh,
  600.                          "State",&sensor_info,&sensorh));
  601.         if (error_code == PICL_SUCCESS) {
  602.              DEBUGMSGTL(("ucd-snmp/lmSensors","Found i2c record size %dn",sensor_info.size));
  603.              ec2 = picl_get_propval(sensorh,&state,sensor_info.size);
  604.              if (ec2 == PICL_SUCCESS){
  605.                  for (st_cnt=0;st_cnt < max_i2c_posns;st_cnt++){
  606.                      if (strncmp(state,i2c_settings[st_cnt],
  607.                            strlen(i2c_settings[st_cnt])) == 0){
  608.                          value=st_cnt;
  609.                          found = 1;
  610.                          break;
  611.                          } 
  612.                      } 
  613.                  if (found==0)
  614.                      value = 99;
  615.                  sensor_array[typ].sensor[sensor_array[typ].n].value = value;
  616.                  snprintf(sensor_array[typ].sensor[sensor_array[typ].n].name,
  617.                      (PICL_PROPNAMELEN_MAX - 1),"%s",propname);
  618.                  sensor_array[typ].sensor[sensor_array[typ].n].
  619.                      name[PICL_PROPNAMELEN_MAX - 1] = '';
  620.                  sensor_array[typ].n++;
  621.                  } 
  622.              else
  623.                  DEBUGMSGTL(("ucd-snmp/lmSensors",
  624.                      "sensor value read error code->%dn",ec2));
  625.             }
  626.         else
  627.             DEBUGMSGTL(("ucd-snmp/lmSensors",
  628.                 "sensor lookup failed  error code->%dn",error_code));
  629.         }
  630. }
  632. static int
  633. process_sensors(int level, picl_nodehdl_t nodeh)
  634. {
  635.     picl_nodehdl_t  childh;
  637.     char propname[PICL_PROPNAMELEN_MAX];
  638.     char propclass[PICL_CLASSNAMELEN_MAX];
  639.     picl_errno_t error_code;
  640.     picl_prophdl_t prop_handle;
  641.     picl_propinfo_t prop_info;
  644.     level++;
  645. /*
  646.     DEBUGMSGTL(("ucd-snmp/lmSensors","Processing sensors level %dn",level));
  647. */
  649.     error_code = picl_get_propval_by_name(nodeh, PICL_PROP_CLASSNAME, propclass,
  650.                                         (PICL_PROPNAMELEN_MAX-1));
  651.     if (error_code != PICL_SUCCESS) {
  652.         DEBUGMSG(("ucd-snmp/lmSensors","Couldn't get propclassn"));
  653.                 return (error_code);
  654.     }
  656.     error_code = picl_get_prop_by_name(nodeh, PICL_PROP_NAME, &prop_handle);
  658.     if (error_code != PICL_SUCCESS) {
  659.         DEBUGMSGTL(("ucd-snmp/lmSensors","Couldn't get prop_handlen"));
  660.         return (error_code);
  662.     }
  664.     error_code = picl_get_propinfo(prop_handle, &prop_info);
  666.     if (error_code != PICL_SUCCESS) {
  667.         DEBUGMSGTL(("ucd-snmp/lmSensors","Couldn't get prop informationn"));
  668.         return (error_code);
  670.     }
  672.     error_code=picl_get_propval(prop_handle, propname, (PICL_PROPNAMELEN_MAX-1));
  674.     DEBUGMSGTL(("ucd-snmp/lmSensors","found propname %s of class %sn",propname, propclass));
  676.     if (error_code != PICL_SUCCESS) {
  677.         DEBUGMSGTL(("ucd-snmp/lmSensors","Couldn't get prop handle by namen"));
  678.         return (error_code);
  680.     }
  682.     if (strstr(propclass,"flashprom"))
  683.        DEBUGMSGTL(("ucd-snmp/lmSensors","found a flashpromn"));
  684.     if (strstr(propclass,"fan-tachometer"))
  685.         process_individual_fan(nodeh,propname);
  686.     if (strstr(propclass,"temperature-sensor"))
  687.         process_temperature_sensor(nodeh,propname);
  688.     if (strstr(propclass,"digital-sensor"))
  689.         process_digital_sensor(nodeh,propname);
  690.     if (strstr(propclass,"switch"))
  691.         process_switch(nodeh,propname);
  692.     if (strstr(propclass,"led"))
  693.         process_led(nodeh,propname);
  694.     if (strstr(propclass,"i2c"))
  695.         process_i2c(nodeh,propname);
  696. /*
  697.         if (strstr(propclass,"gpio"))
  698.             process_gpio(prop_handle,propname); 
  699. */
  700.     for (error_code = picl_get_propval_by_name(nodeh, PICL_PROP_CHILD,
  701.           &childh, sizeof (picl_nodehdl_t)); 
  702.           error_code != PICL_PROPNOTFOUND;
  703.           error_code = picl_get_propval_by_name(childh, PICL_PROP_PEER,
  704.            &childh, sizeof (picl_nodehdl_t))) {
  705.        if (error_code != PICL_SUCCESS) {
  706.             return (error_code);
  707.           }
  709.        /* call itself recursively */
  711.        error_code = process_sensors(level,childh);
  713.        if (error_code != PICL_SUCCESS)
  714.            return (error_code);
  716.        } /* end for */
  718.     return (PICL_SUCCESS);
  721. } /* process sensors */
  723. #endif
  724. /* ******** end of picld sensor procedures * */
  726. #endif /* solaris2 */
  728. static void
  729. _sensor_load(clock_t t)
  730. {
  731. #ifdef solaris2
  732.     int i,j;
  733.     int typ;
  734.     int temp;
  735.     int other;
  736.     const char *fantypes[]={"CPU","PWR","AFB"};
  737.     kstat_ctl_t *kc;
  738.     kstat_t *kp;
  739.     envctrl_fan_t *fan_info;
  740.     envctrl_ps_t *power_info;
  741.     envctrl_encl_t *enc_info;
  743. #ifdef HAVE_PICL_H
  744.     int er_code;
  745.     picl_errno_t     error_code;
  746.     int level=0;
  747.     picl_nodehdl_t  rooth;
  748. #endif 
  750.  DEBUGMSGTL(("ucd-snmp/lmSensors", "Reading the sensorsn")); 
  752. /* initialize the array */
  753.     for (i = 0; i < N_TYPES; i++){
  754.         sensor_array[i].n = 0;
  755.         for (j=0; j < MAX_SENSORS; j++){
  756.             sensor_array[i].sensor[j].name[0] = '';
  757.             sensor_array[i].sensor[j].value = 0;
  758.              }
  759.         } /*end for i*/
  761. /* try picld (if supported), then try kstat */
  762. #ifdef HAVE_PICL_H 
  764. DEBUGMSGTL(("ucd-snmp/lmSensors","trying picld firstn"));
  766. er_code = picl_initialize();
  768. if (er_code == PICL_SUCCESS) {
  770.     DEBUGMSGTL(("ucd-snmp/lmSensors","Got into picldn"));
  772.     error_code = picl_get_root(&rooth);
  774.     if (error_code != PICL_SUCCESS) {
  775.         DEBUGMSGTL(("ucd-snmp/lmSensors", "picld couldn't get root error code->%dn",error_code));
  776.         }
  777.     else{
  778.         DEBUGMSGTL(("ucd-snmp/lmSensors", "found rootn"));
  779.         error_code = process_sensors(level, rooth);
  780.        } /* end else */
  782.     picl_shutdown();
  784. }  /* end if err_code for picl_initialize */
  785. else {
  786.     DEBUGMSGTL(("ucd-snmp/lmSensors","No picld availablen"));
  788. } /*end else picl_initialize */
  790. #endif  /* end of picld section */
  791. /* initialize kstat */
  793. kc = kstat_open();
  794. if (kc == 0) {
  795.     DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't open kstatn"));
  796.     } /* endif kc */
  797. else{
  798.     DEBUGMSGTL(("ucd-snmp/lmSensors", "Opened kstat - looking for sensorsn"));
  799.     kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_FANSTAT);
  800.     if (kp == 0) {
  801.         DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup fan kstatn"));
  802.         } /* endif lookup fans */
  803.     else{
  804.         if (kstat_read(kc, kp, 0) == -1) {
  805.             DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read fan kstatn"));
  806.             } /* endif kstatread fan */
  807.         else{
  808.             typ = 1;
  809.             fan_info = (envctrl_fan_t *) kp->ks_data;
  810.             sensor_array[typ].n = kp->ks_ndata;
  811.             for (i=0; i < kp->ks_ndata; i++){
  812.                 DEBUGMSGTL(("ucd-snmp/lmSensors", "found instance %d fan type %d speed %d OK %d bustedfan %dn",
  813.                     fan_info->instance, fan_info->type,fan_info->fanspeed,fan_info->fans_ok,fan_info->fanflt_num));
  814.                 sensor_array[typ].sensor[i].value = fan_info->fanspeed;
  815.                 snprintf(sensor_array[typ].sensor[i].name,(MAX_NAME - 1),
  816.                    "fan type %s number %d",fantypes[fan_info->type],fan_info->instance);
  817.                 sensor_array[typ].sensor[i].name[MAX_NAME - 1] = '';
  818.                 fan_info++;
  819.                 } /* end for fan_info */
  820.             } /* end else kstatread fan */
  821.         } /* end else lookup fans*/
  824.     kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_PSNAME);
  825.     if (kp == 0) {
  826.         DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup power supply kstatn"));
  827.         } /* endif lookup power supply */
  828.     else{
  829.         if (kstat_read(kc, kp, 0) == -1) {
  830.             DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read power supply kstatn"));
  831.             } /* endif kstatread fan */
  832.         else{
  833.             typ = 2;
  834.             power_info = (envctrl_ps_t *) kp->ks_data;
  835.             sensor_array[typ].n = kp->ks_ndata;
  836.             for (i=0; i < kp->ks_ndata; i++){
  837.                 DEBUGMSGTL(("ucd-snmp/lmSensors", "found instance %d psupply temp %d %dW OK %d share %d limit %dn",
  838.                     power_info->instance, power_info->ps_tempr,power_info->ps_rating,
  839.                     power_info->ps_ok,power_info->curr_share_ok,power_info->limit_ok));
  840.                 sensor_array[typ].sensor[i].value = power_info->ps_tempr;
  841.                 snprintf(sensor_array[typ].sensor[i].name,(MAX_NAME-1),
  842.                          "power supply %d",power_info->instance);
  843.                 sensor_array[typ].sensor[i].name[MAX_NAME - 1] = '';
  844.                 power_info++;
  845.                 } /* end for power_info */
  846.             } /* end else kstatread power supply */
  847.         } /* end else lookup power supplies*/
  849.     kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_ENCL);
  850.     if (kp == 0) {
  851.         DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup enclosure kstatn"));
  852.         } /* endif lookup enclosure */
  853.     else{
  854.         if (kstat_read(kc, kp, 0) == -1) {
  855.             DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read enclosure kstatn"));
  856.             } /* endif kstatread enclosure */
  857.         else{
  858.             enc_info = (envctrl_encl_t *) kp->ks_data; 
  859.             temp = 0;
  860.             other = 0;
  861.             for (i=0; i < kp->ks_ndata; i++){
  862.                switch (enc_info->type){
  863.                case ENVCTRL_ENCL_FSP:
  864.                    DEBUGMSGTL(("ucd-snmp/lmSensors", "front panel value %dn",enc_info->value));
  865.                    typ = 3; /* misc */
  866.                    sensor_array[typ].sensor[other].value = enc_info->value;
  867.                    strncpy(sensor_array[typ].sensor[other].name,"FSP",MAX_NAME-1);
  868.                    sensor_array[typ].sensor[other].name[MAX_NAME-1]=''; /* null terminate */
  869.                    other++;
  870.                    break;
  871.                case ENVCTRL_ENCL_AMBTEMPR:
  872.                    DEBUGMSGTL(("ucd-snmp/lmSensors", "ambient temp %dn",enc_info->value));
  873.                    typ = 0; /* temperature sensor */
  874.                    sensor_array[typ].sensor[temp].value = enc_info->value;
  875.                    strncpy(sensor_array[typ].sensor[temp].name,"Ambient",MAX_NAME-1);
  876.                    sensor_array[typ].sensor[temp].name[MAX_NAME-1]=''; /* null terminate */
  877.                    temp++;
  878.                    break;
  879.                case ENVCTRL_ENCL_BACKPLANE4:
  880.                    DEBUGMSGTL(("ucd-snmp/lmSensors", "There is a backplane4n"));
  881.                    typ = 3; /* misc */
  882.                    sensor_array[typ].sensor[other].value = enc_info->value;
  883.                    strncpy(sensor_array[typ].sensor[other].name,"Backplane4",MAX_NAME-1);
  884.                    sensor_array[typ].sensor[other].name[MAX_NAME-1]=''; /* null terminate */
  885.                    other++;
  886.                    break;
  887.                case ENVCTRL_ENCL_BACKPLANE8:
  888.                    DEBUGMSGTL(("ucd-snmp/lmSensors", "There is a backplane8n"));
  889.                    typ = 3; /* misc */
  890.                    sensor_array[typ].sensor[other].value = enc_info->value;
  891.                    strncpy(sensor_array[typ].sensor[other].name,"Backplane8",MAX_NAME-1);
  892.                    sensor_array[typ].sensor[other].name[MAX_NAME-1]=''; /* null terminate */
  893.                    other++;
  894.                    break;
  895.                case ENVCTRL_ENCL_CPUTEMPR:
  896.                    DEBUGMSGTL(("ucd-snmp/lmSensors", "CPU%d temperature %dn",enc_info->instance,enc_info->value));
  897.                    typ = 0; /* temperature sensor */
  898.                    sensor_array[typ].sensor[temp].value = enc_info->value;
  899.                    snprintf(sensor_array[typ].sensor[temp].name,MAX_NAME,"CPU%d",enc_info->instance);
  900.                    sensor_array[typ].sensor[other].name[MAX_NAME-1]=''; /* null terminate */
  901.                    temp++;
  902.                    break;
  903.                default:
  904.                    DEBUGMSGTL(("ucd-snmp/lmSensors", "unknown element instance &d type &d value %dn",
  905.                        enc_info->instance, enc_info->type, enc_info->value));
  906.                    break;
  907.                } /* end switch */
  908.                enc_info++;
  909.                } /* end for enc_info */
  910.                sensor_array[3].n = other;
  911.                sensor_array[0].n = temp;
  912.             } /* end else kstatread enclosure */
  913.         } /* end else lookup enclosure*/
  915.     kstat_close(kc);
  918. } /* end else kstat */
  919. #else /* end solaris2 */
  921.     const sensors_chip_name *chip;
  922.     const sensors_feature_data *data;
  923.     int             chip_nr = 0;
  925.     int             i;
  926.     for (i = 0; i < N_TYPES; i++)
  927.         sensor_array[i].n = 0;
  929.     while ((chip = sensors_get_detected_chips(&chip_nr))) {
  930. int             a = 0;
  931. int             b = 0;
  932.         while ((data = sensors_get_all_features(*chip, &a, &b))) {
  933.             char           *label = NULL;
  934.             double          val;
  936.             if ((data->mode & SENSORS_MODE_R) &&
  937.                 (data->mapping == SENSORS_NO_MAPPING) &&
  938.                 !sensors_get_label(*chip, data->number, &label) &&
  939.                 !sensors_get_feature(*chip, data->number, &val)) {
  940.                 int             type = -1;
  941.                 float           mul;
  942.                 _sensor_array  *array;
  945.                 if (strstr(label, "V")) {
  946.                     type = 2;
  947.                     mul = 1000.0;
  948.                 }
  949.                 if (strstr(label, "fan") || strstr(label, "Fan")) {
  950.                     type = 1;
  951.                     mul = 1.0;
  952.                 }
  953.                 if (strstr(label, "temp") || strstr(label, "Temp")) {
  954.                     type = 0;
  955.                     mul = 1000.0;
  956.                 }
  957.                 if (type == -1) {
  958.                     type = 3;
  959.                     mul = 1000.0;
  960.                 }
  962.                 array = &sensor_array[type];
  963.                 if (MAX_SENSORS <= array->n) {
  964.                     snmp_log(LOG_ERR, "too many sensors. ignoring %sn", label);
  965.                     break;
  966.                 }
  967.                 strncpy(array->sensor[array->n].name, label, MAX_NAME);
  968.                 array->sensor[array->n].value = (int) (val * mul);
  969.                 DEBUGMSGTL(("ucd-snmp/lmSensors","sensor %d, value %dn",
  970.                             array->sensor[array->n].name,
  971.                             array->sensor[array->n].value));
  972.                 array->n++;
  973.             }
  974.     if (label) {
  975. free(label);
  976. label = NULL;
  977.     }
  978.         }
  979.     }
  980. #endif /*else solaris2 */
  981.     timestamp = t;
  982. }