Provided by: libsensors4-dev_3.3.1-2ubuntu1_i386 bug

NAME

       libsensors  -  publicly  accessible  functions  provided by the sensors
       library

SYNOPSIS

       #include <sensors/sensors.h>

       /* Library initialization and clean-up */
       int sensors_init(FILE *input);
       void sensors_cleanup(void);
       const char *libsensors_version;

       /* Chip name handling */
       int sensors_parse_chip_name(const char *orig_name,
                                   sensors_chip_name *res);
       void sensors_free_chip_name(sensors_chip_name *chip);
       int sensors_snprintf_chip_name(char *str, size_t size,
                                      const sensors_chip_name *chip);
       const char *sensors_get_adapter_name(const sensors_bus_id *bus);

       /* Chips and features enumeration */
       const sensors_chip_name *
       sensors_get_detected_chips(const sensors_chip_name *match,
                                  int *nr);
       const sensors_feature *
       sensors_get_features(const sensors_chip_name *name,
                            int *nr);
       const sensors_subfeature *
       sensors_get_all_subfeatures(const sensors_chip_name *name,
                                   const sensors_feature *feature,
                                   int *nr);
       const sensors_subfeature *
       sensors_get_subfeature(const sensors_chip_name *name,
                              const sensors_feature *feature,
                              sensors_subfeature_type type);

       /* Features access */
       char *sensors_get_label(const sensors_chip_name *name,
                               const sensors_feature *feature);
       int sensors_get_value(const sensors_chip_name *name, int subfeat_nr,
                             double *value);
       int sensors_set_value(const sensors_chip_name *name, int subfeat_nr,
                             double value);
       int sensors_do_chip_sets(const sensors_chip_name *name);

       #include <sensors/error.h>

       /* Error decoding */
       const char *sensors_strerror(int errnum);

       /* Error handlers */
       void (*sensors_parse_error) (const char *err, int lineno);
       void (*sensors_parse_error_wfn) (const char *err,
                                        const char *filename, int lineno);
       void (*sensors_fatal_error) (const char *proc, const char *err);

DESCRIPTION

       sensors_init() loads the configuration  file  and  the  detected  chips
       list.  If this returns a value unequal to zero, you are in trouble; you
       can not assume anything will be initialized properly. If  you  want  to
       reload  the  configuration  file,  call  sensors_cleanup() below before
       calling sensors_init() again.

       If FILE is NULL, the default configuration  files  are  used  (see  the
       FILES section below). Most applications will want to do that.

       sensors_cleanup() cleans everything up: you can't access anything after
       this, until the next sensors_init() call!

       libsensors_version is a string representing the version of libsensors.

       sensors_parse_chip_name()  parses  a  chip   name   to   the   internal
       representation.  Return  0  on  success, <0 on error. Make sure to call
       sensors_free_chip_name() when you're done with the data.

       sensors_free_chip_name() frees the memory that may have been  allocated
       for  the  internal representation of a chip name. You only have to call
       this for chip names which do not originate from libsensors itself (that
       is, chip names which were generated by sensors_parse_chip_name()).

       sensors_snprintf_chip_name()  prints  a  chip  name  from  its internal
       representation. Note that chip  should  not  contain  wildcard  values!
       Return  the number of characters printed on success (same as snprintf),
       <0 on error.

       sensors_get_adapter_name() returns the adapter name of a bus number, as
       used  within the sensors_chip_name structure. If it could not be found,
       it returns NULL.

       sensors_get_detected_chips() returns all detected chips  that  match  a
       given  chip name, one by one. If no chip name is provided, all detected
       chips are returned.  To start at the beginning of the list, use  0  for
       nr;  NULL  is  returned if we are at the end of the list. Do not try to
       change these chip names, as they point to internal structures!

       sensors_get_features() returns all main features of a specific chip. nr
       is an internally used variable. Set it to zero to start at the begin of
       the list. If no more features are found NULL is returned.  Do  not  try
       to  change  the  returned  structure;  you  will  corrupt internal data
       structures.

       sensors_get_all_subfeatures() returns all subfeatures of a  given  main
       feature.  nr is an internally used variable. Set it to zero to start at
       the begin of the list.  If  no  more  subfeatures  are  found  NULL  is
       returned.   Do  not  try  to  change  the  returned structure; you will
       corrupt internal data structures.

       sensors_get_subfeature() returns the subfeature of the given type for a
       given main feature, if it exists, NULL otherwise.  Do not try to change
       the returned structure; you will corrupt internal data structures.

       sensors_get_label() looks up the label which belongs to this chip. Note
       that  chip  should  not contain wildcard values! The returned string is
       newly allocated (free it yourself). On failure, NULL is  returned.   If
       no label exists for this feature, its name is returned itself.

       sensors_get_value()  Reads the value of a subfeature of a certain chip.
       Note that chip should not contain wildcard values! This  function  will
       return 0 on success, and <0 on failure.

       sensors_set_value()  sets  the value of a subfeature of a certain chip.
       Note that chip should not contain wildcard values! This  function  will
       return 0 on success, and <0 on failure.

       sensors_do_chip_sets()  executes all set statements for this particular
       chip. The chip may contain wildcards!  This function will return  0  on
       success, and <0 on failure.

       sensors_strerror()  returns  a  pointer to a string which describes the
       error.  errnum may be negative (the  corresponding  positive  error  is
       returned).  You may not modify the result!

       sensors_parse_error() and sensors_parse_error_wfn() are functions which
       are called when a parse error is detected. Give them  new  values,  and
       your  own  functions  are called instead of the default (which print to
       stderr). These functions may terminate the program,  but  they  usually
       output an error and return. The first function is the original one, the
       second one was added later  when  support  for  multiple  configuration
       files  was added.  The library code now only calls the second function.
       However, for backwards compatibility,  if  an  application  provides  a
       custom  handling  function  for  the first function but not the second,
       then all parse errors will be reported using the first  function  (that
       is,  the  filename  is never reported.)  Note that filename can be NULL
       (if filename isn't known) and lineno can be  0  (if  the  error  occurs
       before the actual parsing starts.)

       sensors_fatal_error() Is a function which is called when an immediately
       fatal error (like no memory left) is detected. Give it a new value, and
       your  own  function  is  called instead of the default (which prints to
       stderr and ends the program). Never let it return!

DATA STRUCTURES

       Structure sensors_feature  contains  information  related  to  a  given
       feature of a specific chip:

       typedef struct sensors_feature {
            const char *name;
            int number;
            sensors_feature_type type;
       } sensors_feature;

       There  are  other members not documented here, which are only meant for
       libsensors internal use.

       Structure sensors_subfeature contains information related  to  a  given
       subfeature of a specific chip feature:

       typedef struct sensors_subfeature {
            const char *name;
            int number;
            sensors_subfeature_type type;
            int mapping;
            unsigned int flags;
       } sensors_subfeature;

       The  flags  field  is  a  bitfield,  its  value  is  a  combination  of
       SENSORS_MODE_R    (readable),     SENSORS_MODE_W     (writable)     and
       SENSORS_COMPUTE_MAPPING  (affected by the computation rules of the main
       feature).

FILES

       /etc/sensors3.conf
       /etc/sensors.conf
              The    system-wide     libsensors(3)     configuration     file.
              /etc/sensors3.conf  is  tried  first,  and  if it doesn't exist,
              /etc/sensors.conf is used instead.

       /etc/sensors.d
              A  directory   where   you   can   put   additional   libsensors
              configuration  files.   Files  found  in  this directory will be
              processed in alphabetical order after the default  configuration
              file. Files with names that start with a dot are ignored.

SEE ALSO

       sensors.conf(5)

AUTHOR

       Frodo Looijaard and the lm_sensors group http://www.lm-sensors.org/