root/lm-sensors/branches/lm-sensors-3.0.0/lib/init.c @ 5163

Revision 5163, 4.8 KB (checked in by khali, 6 years ago)

Patch from Aurelien Jarno:

I have just noticed that the FSF address is the old one in all files
except COPYING. Please find a patch below to fix that.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2    init.c - Part of libsensors, a Linux library for reading sensor data.
3    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
4    Copyright (C) 2007        Jean Delvare <khali@linux-fr.org>
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19    MA 02110-1301 USA.
20*/
21
22#include <stdlib.h>
23#include <stdio.h>
24#include <errno.h>
25#include "sensors.h"
26#include "data.h"
27#include "error.h"
28#include "access.h"
29#include "conf.h"
30#include "sysfs.h"
31#include "scanner.h"
32#include "init.h"
33
34#define DEFAULT_CONFIG_FILE     ETCDIR "/sensors3.conf"
35#define ALT_CONFIG_FILE         ETCDIR "/sensors.conf"
36
37int sensors_init(FILE *input)
38{
39        int res;
40
41        if (!sensors_init_sysfs())
42                return -SENSORS_ERR_KERNEL;
43        if ((res = sensors_read_sysfs_bus()) ||
44            (res = sensors_read_sysfs_chips()))
45                goto exit_cleanup;
46
47        res = -SENSORS_ERR_PARSE;
48        if (input) {
49                if (sensors_scanner_init(input) ||
50                    sensors_yyparse())
51                        goto exit_cleanup;
52        } else {
53                /* No configuration provided, use default */
54                input = fopen(DEFAULT_CONFIG_FILE, "r");
55                if (!input && errno == ENOENT)
56                        input = fopen(ALT_CONFIG_FILE, "r");
57                if (input) {
58                        if (sensors_scanner_init(input) ||
59                            sensors_yyparse()) {
60                                fclose(input);
61                                goto exit_cleanup;
62                        }
63                        fclose(input);
64                }
65        }
66
67        if ((res = sensors_substitute_busses()))
68                goto exit_cleanup;
69        return 0;
70
71exit_cleanup:
72        sensors_cleanup();
73        return res;
74}
75
76static void free_chip_name(sensors_chip_name *name)
77{
78        free(name->prefix);
79        free(name->path);
80}
81
82static void free_chip_features(sensors_chip_features *features)
83{
84        int i;
85
86        for (i = 0; i < features->subfeature_count; i++)
87                free(features->subfeature[i].name);
88        free(features->subfeature);
89        for (i = 0; i < features->feature_count; i++)
90                free(features->feature[i].name);
91        free(features->feature);
92}
93
94static void free_bus(sensors_bus *bus)
95{
96        free(bus->adapter);
97}
98
99static void free_label(sensors_label *label)
100{
101        free(label->name);
102        free(label->value);
103}
104
105void free_expr(sensors_expr *expr)
106{
107        if (expr->kind == sensors_kind_var)
108                free(expr->data.var);
109        else if (expr->kind == sensors_kind_sub) {
110                if (expr->data.subexpr.sub1)
111                        free_expr(expr->data.subexpr.sub1);
112                if (expr->data.subexpr.sub2)
113                        free_expr(expr->data.subexpr.sub2);
114        }
115        free(expr);
116}
117
118static void free_set(sensors_set *set)
119{
120        free(set->name);
121        free_expr(set->value);
122}
123
124static void free_compute(sensors_compute *compute)
125{
126        free(compute->name);
127        free_expr(compute->from_proc);
128        free_expr(compute->to_proc);
129}
130
131static void free_ignore(sensors_ignore *ignore)
132{
133        free(ignore->name);
134}
135
136static void free_chip(sensors_chip *chip)
137{
138        int i;
139
140        for (i = 0; i < chip->chips.fits_count; i++)
141                free_chip_name(&chip->chips.fits[i]);
142        free(chip->chips.fits);
143        chip->chips.fits_count = chip->chips.fits_max = 0;
144
145        for (i = 0; i < chip->labels_count; i++)
146                free_label(&chip->labels[i]);
147        free(chip->labels);
148        chip->labels_count = chip->labels_max = 0;
149
150        for (i = 0; i < chip->sets_count; i++)
151                free_set(&chip->sets[i]);
152        free(chip->sets);
153        chip->sets_count = chip->sets_max = 0;
154
155        for (i = 0; i < chip->computes_count; i++)
156                free_compute(&chip->computes[i]);
157        free(chip->computes);
158        chip->computes_count = chip->computes_max = 0;
159
160        for (i = 0; i < chip->ignores_count; i++)
161                free_ignore(&chip->ignores[i]);
162        free(chip->ignores);
163        chip->ignores_count = chip->ignores_max = 0;
164}
165
166void sensors_cleanup(void)
167{
168        int i;
169
170        sensors_scanner_exit();
171
172        for (i = 0; i < sensors_proc_chips_count; i++) {
173                free_chip_name(&sensors_proc_chips[i].chip);
174                free_chip_features(&sensors_proc_chips[i]);
175        }
176        free(sensors_proc_chips);
177        sensors_proc_chips = NULL;
178        sensors_proc_chips_count = sensors_proc_chips_max = 0;
179
180        for (i = 0; i < sensors_config_busses_count; i++)
181                free_bus(&sensors_config_busses[i]);
182        free(sensors_config_busses);
183        sensors_config_busses = NULL;
184        sensors_config_busses_count = sensors_config_busses_max = 0;
185
186        for (i = 0; i < sensors_config_chips_count; i++)
187                free_chip(&sensors_config_chips[i]);
188        free(sensors_config_chips);
189        sensors_config_chips = NULL;
190        sensors_config_chips_count = sensors_config_chips_max = 0;
191
192        for (i = 0; i < sensors_proc_bus_count; i++)
193                free_bus(&sensors_proc_bus[i]);
194        free(sensors_proc_bus);
195        sensors_proc_bus = NULL;
196        sensors_proc_bus_count = sensors_proc_bus_max = 0;
197}
Note: See TracBrowser for help on using the browser.