1 /* $NetBSD: config.c,v 1.15 2024/10/06 19:08:34 rillig Exp $ */
2
3 /*-
4 * Copyright (c) 2007 Juan Romero Pardines.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 #ifndef lint
30 __RCSID("$NetBSD: config.c,v 1.15 2024/10/06 19:08:34 rillig Exp $");
31 #endif /* not lint */
32
33 #include <inttypes.h>
34 #include <stdbool.h>
35 #include <stdio.h>
36 #include <string.h>
37 #include <stdlib.h>
38 #include <err.h>
39 #include <errno.h>
40 #include <sys/queue.h>
41 #include <prop/proplib.h>
42
43 #include "envstat.h"
44
45 /*
46 * Singly linked list for dictionaries that store properties
47 * in a sensor.
48 */
49 static SLIST_HEAD(, sensor_block) sensor_block_list =
50 SLIST_HEAD_INITIALIZER(&sensor_block_list);
51
52 /*
53 * Singly linked list for devices that store a proplib array
54 * device with a device name.
55 */
56 static SLIST_HEAD(, device_block) device_block_list =
57 SLIST_HEAD_INITIALIZER(&device_block_list);
58
59 enum {
60 VALUE_ERR,
61 PROP_ERR,
62 SENSOR_ERR,
63 DEV_ERR
64 };
65
66 static prop_dictionary_t cfdict, sensordict, refreshdict;
67 __dead static void config_errmsg(int, const char *, const char *);
68
69 static void
config_errmsg(int lvl,const char * key,const char * key2)70 config_errmsg(int lvl, const char *key, const char *key2)
71 {
72 (void)printf("envstat: ");
73
74 switch (lvl) {
75 case VALUE_ERR:
76 (void)printf("invalid value for '%s' in `%s'\n",
77 key, key2);
78 break;
79 case PROP_ERR:
80 (void)printf("the '%s' property is not allowed "
81 "in `%s'\n", key, key2);
82 break;
83 case SENSOR_ERR:
84 (void)printf("'%s' is not a valid sensor in the "
85 "`%s' device\n", key, key2);
86 break;
87 case DEV_ERR:
88 (void)printf("device `%s' doesn't exist\n", key);
89 break;
90 }
91
92 (void)printf("envstat: please fix the configuration file!\n");
93 exit(EXIT_FAILURE);
94 }
95
96 /*
97 * Adds a property into a temporary dictionary.
98 */
99 void
config_dict_add_prop(const char * key,char * value)100 config_dict_add_prop(const char *key, char *value)
101 {
102
103 if (!key || !value)
104 return;
105
106 if (!sensordict) {
107 sensordict = prop_dictionary_create();
108 if (!sensordict)
109 err(EXIT_FAILURE, "sensordict");
110 }
111
112 if (!prop_dictionary_set_string(sensordict, key, value))
113 err(EXIT_FAILURE, "prop_dict_set_string");
114 }
115
116 /*
117 * Marks sensor's dictionary to say that it's the last property
118 * and the dictionary should be added into the singly linked list.
119 */
120 void
config_dict_mark(void)121 config_dict_mark(void)
122 {
123 struct sensor_block *sb;
124
125 sb = calloc(1, sizeof(*sb));
126 if (!sb)
127 err(EXIT_FAILURE, "!sb");
128
129 sb->dict = prop_dictionary_create();
130 if (!sb->dict)
131 err(EXIT_FAILURE, "!sb->dict");
132
133 sb->dict = prop_dictionary_copy(sensordict);
134 SLIST_INSERT_HEAD(&sensor_block_list, sb, sb_head);
135 config_dict_destroy(sensordict);
136 }
137
138 /*
139 * Show raw data
140 */
141 void
config_dict_dump(prop_dictionary_t d)142 config_dict_dump(prop_dictionary_t d)
143 {
144 char *buf;
145
146 buf = prop_dictionary_externalize(d);
147 (void)printf("%s", buf);
148 free(buf);
149 }
150
151 static void
display_object(prop_object_t obj,bool nflag)152 display_object(prop_object_t obj, bool nflag)
153 {
154 char *xml;
155 prop_object_t next_obj;
156 prop_object_iterator_t iter;
157
158 if (obj == NULL)
159 exit(EXIT_FAILURE);
160 switch (prop_object_type(obj)) {
161 case PROP_TYPE_BOOL:
162 printf("%s\n", prop_bool_true(obj) ? "true" : "false");
163 break;
164 case PROP_TYPE_NUMBER:
165 printf("%" PRId64 "\n", prop_number_signed_value(obj));
166 break;
167 case PROP_TYPE_STRING:
168 printf("%s\n", prop_string_value(obj));
169 break;
170 case PROP_TYPE_DICTIONARY:
171 xml = prop_dictionary_externalize(obj);
172 printf("%s", xml);
173 free(xml);
174 break;
175 case PROP_TYPE_ARRAY:
176 iter = prop_array_iterator(obj);
177 if (!nflag)
178 printf("Array:\n");
179 while ((next_obj = prop_object_iterator_next(iter)) != NULL)
180 display_object(next_obj, nflag);
181 break;
182 default:
183 errx(EXIT_FAILURE, "Unhandled type %d", prop_object_type(obj));
184 }
185 }
186
187 void
config_dict_extract(prop_dictionary_t dict,const char * prop,bool nflag)188 config_dict_extract(prop_dictionary_t dict, const char *prop, bool nflag)
189 {
190 char *s, *p, *cur, *ep = NULL;
191 prop_object_t obj;
192 unsigned long ind;
193
194 obj = dict;
195 cur = NULL;
196 s = strdup(prop);
197 p = strtok_r(s, "/", &ep);
198 while (p) {
199 cur = p;
200 p = strtok_r(NULL, "/", &ep);
201
202 switch (prop_object_type(obj)) {
203 case PROP_TYPE_DICTIONARY:
204 obj = prop_dictionary_get(obj, cur);
205 if (obj == NULL)
206 exit(EXIT_FAILURE);
207 break;
208 case PROP_TYPE_ARRAY:
209 ind = strtoul(cur, NULL, 0);
210 obj = prop_array_get(obj, ind);
211 if (obj == NULL)
212 exit(EXIT_FAILURE);
213 break;
214 default:
215 errx(EXIT_FAILURE, "Select neither dict nor array with"
216 " `%s'", cur);
217 }
218 }
219
220 if (obj != NULL && cur != NULL)
221 display_object(obj, nflag);
222
223 free(s);
224 }
225
226 /*
227 * Returns the global dictionary.
228 */
229 prop_dictionary_t
config_dict_parsed(void)230 config_dict_parsed(void)
231 {
232 return cfdict;
233 }
234
235 /*
236 * To add device properties into the global array, for now only the
237 * 'refresh-timeout' property is accepted.
238 */
239 void
config_dict_adddev_prop(const char * key,const char * value,int line)240 config_dict_adddev_prop(const char *key, const char *value, int line)
241 {
242 prop_dictionary_t d = NULL;
243 uint64_t timo;
244 size_t len;
245 char *endptr, *strval;
246 bool minutes, hours;
247
248 minutes = hours = false;
249
250 /*
251 * Check what was specified: seconds, minutes or hours.
252 */
253 if (strchr(value, 's')) {
254 /*
255 * do nothing, by default the value will be sent as seconds.
256 */
257 } else if (strchr(value, 'm')) {
258 minutes = true;
259 } else if (strchr(value, 'h')) {
260 hours = true;
261 } else
262 goto bad;
263
264 len = strlen(value);
265 strval = calloc(len, sizeof(*value));
266 if (!strval)
267 err(EXIT_FAILURE, "calloc");
268
269 (void)strlcpy(strval, value, len);
270
271 timo = strtoul(strval, &endptr, 10);
272 if (*endptr != '\0') {
273 free(strval);
274 goto bad;
275 }
276
277 free(strval);
278
279 refreshdict = prop_dictionary_create();
280 if (!refreshdict)
281 err(EXIT_FAILURE, "prop_dict_create refresh");
282
283 d = prop_dictionary_create();
284 if (!d)
285 err(EXIT_FAILURE, "prop_dict_create refresh 1");
286
287 if (minutes)
288 timo *= 60;
289 else if (hours) {
290 /*
291 * Make sure the value is not too high...
292 */
293 if (timo > 999)
294 goto bad;
295 timo *= 60 * 60;
296 } else {
297 /*
298 * 1 second is the lowest value allowed.
299 */
300 if (timo < 1)
301 goto bad;
302 }
303
304 if (!prop_dictionary_set_uint64(d, key, timo))
305 err(EXIT_FAILURE, "%s", key);
306
307 if (!prop_dictionary_set(refreshdict, "device-properties", d))
308 err(EXIT_FAILURE, "device-properties %s", key);
309
310 prop_object_release(d);
311 return;
312
313 bad:
314 (void)printf("envstat: invalid value for the '%s' "
315 "property at line %d\n", key, line);
316 (void)printf("envstat: please fix the configuration file!\n");
317 if (d)
318 prop_object_release(d);
319
320 exit(EXIT_FAILURE);
321 }
322
323 /*
324 * Destroys all objects from a dictionary.
325 */
326 void
config_dict_destroy(prop_dictionary_t d)327 config_dict_destroy(prop_dictionary_t d)
328 {
329 prop_object_iterator_t iter;
330 prop_object_t obj;
331
332 iter = prop_dictionary_iterator(d);
333 if (!iter)
334 err(EXIT_FAILURE, "!iter");
335
336 while ((obj = prop_object_iterator_next(iter)) != NULL) {
337 prop_dictionary_remove(d,
338 prop_dictionary_keysym_value(obj));
339 prop_object_iterator_reset(iter);
340 }
341
342 prop_object_iterator_release(iter);
343 }
344
345 /*
346 * Parses all properties on the device and adds the device
347 * into the singly linked list for devices and the global dictionary.
348 */
349 void
config_devblock_add(const char * key,prop_dictionary_t kdict)350 config_devblock_add(const char *key, prop_dictionary_t kdict)
351 {
352 struct device_block *db;
353 struct sensor_block *sb;
354 prop_array_t array;
355 prop_object_iterator_t iter;
356 prop_dictionary_t sdict;
357 prop_object_t obj;
358 prop_string_t lindex;
359 const char *sensor;
360 bool sensor_found = false;
361
362 if (!key)
363 err(EXIT_FAILURE, "devblock !key");
364
365 array = prop_dictionary_get(kdict, key);
366 if (!array)
367 config_errmsg(DEV_ERR, key, NULL);
368
369 SLIST_FOREACH(sb, &sensor_block_list, sb_head) {
370 /* get the index object value from configuration */
371 lindex = prop_dictionary_get(sb->dict, "index");
372 sensor = prop_string_value(lindex);
373
374 iter = prop_array_iterator(array);
375 if (!iter)
376 err(EXIT_FAILURE, "prop_array_iterator devblock");
377
378 /*
379 * Get the correct sensor's dictionary from kernel's
380 * dictionary.
381 */
382 while ((sdict = prop_object_iterator_next(iter)) != NULL) {
383 obj = prop_dictionary_get(sdict, "index");
384 if (prop_string_equals(lindex, obj)) {
385 sensor_found = true;
386 break;
387 }
388 }
389
390 if (!sensor_found) {
391 prop_object_iterator_release(iter);
392 config_errmsg(SENSOR_ERR, sensor, key);
393 }
394
395 config_devblock_check_sensorprops(sdict, sb->dict, sensor);
396 prop_object_iterator_release(iter);
397 }
398
399 db = calloc(1, sizeof(*db));
400 if (!db)
401 err(EXIT_FAILURE, "calloc db");
402
403 db->array = prop_array_create();
404 if (!db->array)
405 err(EXIT_FAILURE, "prop_array_create devblock");
406
407 /*
408 * Add all dictionaries into the array.
409 */
410 SLIST_FOREACH(sb, &sensor_block_list, sb_head)
411 if (!prop_array_add(db->array, sb->dict))
412 err(EXIT_FAILURE, "prop_array_add");
413
414 /*
415 * Add the device-properties dictionary into the array.
416 */
417 if (refreshdict) {
418 if (!prop_array_add(db->array, refreshdict))
419 err(EXIT_FAILURE, "prop_array_add refreshdict");
420 prop_object_release(refreshdict);
421 }
422
423 /*
424 * Add this device block into our list.
425 */
426 db->dev_key = strdup(key);
427 SLIST_INSERT_HEAD(&device_block_list, db, db_head);
428
429 /*
430 * Remove all items in the list, but just decrement
431 * the refcnt in the dictionaries... they are in use.
432 */
433 while (!SLIST_EMPTY(&sensor_block_list)) {
434 sb = SLIST_FIRST(&sensor_block_list);
435 SLIST_REMOVE_HEAD(&sensor_block_list, sb_head);
436 prop_object_release(sb->dict);
437 free(sb);
438 }
439
440 /*
441 * Now the properties on the array has been parsed,
442 * add it into the global dict.
443 */
444 if (!cfdict) {
445 cfdict = prop_dictionary_create();
446 if (!cfdict)
447 err(EXIT_FAILURE, "prop_dictionary_create cfdict");
448 }
449
450 if (!prop_dictionary_set(cfdict, key, db->array))
451 err(EXIT_FAILURE, "prop_dictionary_set db->array");
452
453 /*
454 * refreshdict must be NULLed to avoid false positives in
455 * next matches.
456 */
457 refreshdict = NULL;
458 }
459
460 /*
461 * Returns the dictionary that has 'sensor_key' in the 'dvname'
462 * array.
463 */
464 prop_dictionary_t
config_devblock_getdict(const char * dvname,const char * sensor_key)465 config_devblock_getdict(const char *dvname, const char *sensor_key)
466 {
467 struct device_block *db;
468 prop_object_iterator_t iter;
469 prop_object_t obj, obj2;
470
471 if (!dvname || !sensor_key)
472 return NULL;
473
474 SLIST_FOREACH(db, &device_block_list, db_head)
475 if (strcmp(db->dev_key, dvname) == 0)
476 break;
477
478 if (!db)
479 return NULL;
480
481 iter = prop_array_iterator(db->array);
482 if (!iter)
483 return NULL;
484
485 while ((obj = prop_object_iterator_next(iter)) != NULL) {
486 obj2 = prop_dictionary_get(obj, "index");
487 if (prop_string_equals_string(obj2, sensor_key))
488 break;
489 }
490
491 prop_object_iterator_release(iter);
492 return obj;
493 }
494
495 /*
496 * Checks that all properties specified in the configuration file
497 * are valid and updates the objects with proper values.
498 */
499 void
config_devblock_check_sensorprops(prop_dictionary_t ksdict,prop_dictionary_t csdict,const char * sensor)500 config_devblock_check_sensorprops(prop_dictionary_t ksdict,
501 prop_dictionary_t csdict,
502 const char *sensor)
503 {
504 prop_object_t obj, obj2, obj3;
505 const char *strval;
506 char *endptr;
507 double val;
508
509 /*
510 * rfact property set?
511 */
512 obj = prop_dictionary_get(csdict, "rfact");
513 if (obj) {
514 obj2 = prop_dictionary_get(ksdict, "allow-rfact");
515 if (prop_bool_true(obj2)) {
516 strval = prop_string_value(obj);
517 val = strtod(strval, &endptr);
518 if (*endptr != '\0')
519 config_errmsg(VALUE_ERR, "rfact", sensor);
520
521 if (!prop_dictionary_set_uint32(csdict, "rfact", val))
522 err(EXIT_FAILURE, "dict_set rfact");
523 } else
524 config_errmsg(PROP_ERR, "rfact", sensor);
525 }
526
527 /*
528 * critical-capacity property set?
529 */
530 obj = prop_dictionary_get(csdict, "critical-capacity");
531 if (obj) {
532 obj2 = prop_dictionary_get(ksdict, "want-percentage");
533 obj3 = prop_dictionary_get(ksdict, "monitoring-supported");
534 if (prop_bool_true(obj2) && prop_bool_true(obj3)) {
535 strval = prop_string_value(obj);
536 val = strtod(strval, &endptr);
537 if ((*endptr != '\0') || (val < 0 || val > 100))
538 config_errmsg(VALUE_ERR,
539 "critical-capacity",
540 sensor);
541 /*
542 * Convert the value to a valid percentage.
543 */
544 obj = prop_dictionary_get(ksdict, "max-value");
545 val = (val / 100) * prop_number_signed_value(obj);
546
547 if (!prop_dictionary_set_uint32(csdict,
548 "critical-capacity",
549 val))
550 err(EXIT_FAILURE, "dict_set critcap");
551 } else
552 config_errmsg(PROP_ERR, "critical-capacity", sensor);
553 }
554
555 /*
556 * warning-capacity property set?
557 */
558 obj = prop_dictionary_get(csdict, "warning-capacity");
559 if (obj) {
560 obj2 = prop_dictionary_get(ksdict, "want-percentage");
561 obj3 = prop_dictionary_get(ksdict, "monitoring-supported");
562 if (prop_bool_true(obj2) && prop_bool_true(obj3)) {
563 strval = prop_string_value(obj);
564 val = strtod(strval, &endptr);
565 if ((*endptr != '\0') || (val < 0 || val > 100))
566 config_errmsg(VALUE_ERR,
567 "warning-capacity",
568 sensor);
569 /*
570 * Convert the value to a valid percentage.
571 */
572 obj = prop_dictionary_get(ksdict, "max-value");
573 val = (val / 100) * prop_number_signed_value(obj);
574
575 if (!prop_dictionary_set_uint32(csdict,
576 "warning-capacity",
577 val))
578 err(EXIT_FAILURE, "dict_set warncap");
579 } else
580 config_errmsg(PROP_ERR, "warning-capacity", sensor);
581 }
582
583 /*
584 * high-capacity property set?
585 */
586 obj = prop_dictionary_get(csdict, "high-capacity");
587 if (obj) {
588 obj2 = prop_dictionary_get(ksdict, "want-percentage");
589 obj3 = prop_dictionary_get(ksdict, "monitoring-supported");
590 if (prop_bool_true(obj2) && prop_bool_true(obj3)) {
591 strval = prop_string_value(obj);
592 val = strtod(strval, &endptr);
593 if ((*endptr != '\0') || (val < 0 || val > 100))
594 config_errmsg(VALUE_ERR,
595 "high-capacity",
596 sensor);
597 /*
598 * Convert the value to a valid percentage.
599 */
600 obj = prop_dictionary_get(ksdict, "max-value");
601 val = (val / 100) * prop_number_signed_value(obj);
602
603 if (!prop_dictionary_set_uint32(csdict,
604 "high-capacity",
605 val))
606 err(EXIT_FAILURE, "dict_set highcap");
607 } else
608 config_errmsg(PROP_ERR, "high-capacity", sensor);
609 }
610
611 /*
612 * maximum-capacity property set?
613 */
614 obj = prop_dictionary_get(csdict, "maximum-capacity");
615 if (obj) {
616 obj2 = prop_dictionary_get(ksdict, "want-percentage");
617 obj3 = prop_dictionary_get(ksdict, "monitoring-supported");
618 if (prop_bool_true(obj2) && prop_bool_true(obj3)) {
619 strval = prop_string_value(obj);
620 val = strtod(strval, &endptr);
621 if ((*endptr != '\0') || (val < 0 || val > 100))
622 config_errmsg(VALUE_ERR,
623 "maximum-capacity",
624 sensor);
625 /*
626 * Convert the value to a valid percentage.
627 */
628 obj = prop_dictionary_get(ksdict, "max-value");
629 val = (val / 100) * prop_number_signed_value(obj);
630
631 if (!prop_dictionary_set_uint32(csdict,
632 "maximum-capacity",
633 val))
634 err(EXIT_FAILURE, "dict_set maxcap");
635 } else
636 config_errmsg(PROP_ERR, "maximum-capacity", sensor);
637 }
638
639 /*
640 * critical-max property set?
641 */
642 obj = prop_dictionary_get(csdict, "critical-max");
643 if (obj) {
644 obj2 = prop_dictionary_get(ksdict, "monitoring-supported");
645 if (!prop_bool_true(obj2))
646 config_errmsg(PROP_ERR, "critical-max", sensor);
647
648 strval = prop_string_value(obj);
649 obj = convert_val_to_pnumber(ksdict, "critical-max",
650 sensor, strval);
651 if (!prop_dictionary_set(csdict, "critical-max", obj))
652 err(EXIT_FAILURE, "prop_dict_set cmax");
653 }
654
655 /*
656 * critical-min property set?
657 */
658 obj = prop_dictionary_get(csdict, "critical-min");
659 if (obj) {
660 obj2 = prop_dictionary_get(ksdict, "monitoring-supported");
661 if (!prop_bool_true(obj2))
662 config_errmsg(PROP_ERR, "critical-min", sensor);
663
664 strval = prop_string_value(obj);
665 obj = convert_val_to_pnumber(ksdict, "critical-min",
666 sensor, strval);
667 if (!prop_dictionary_set(csdict, "critical-min", obj))
668 err(EXIT_FAILURE, "prop_dict_set cmin");
669 }
670
671 /*
672 * warning-max property set?
673 */
674 obj = prop_dictionary_get(csdict, "warning-max");
675 if (obj) {
676 obj2 = prop_dictionary_get(ksdict, "monitoring-supported");
677 if (!prop_bool_true(obj2))
678 config_errmsg(PROP_ERR, "warning-max", sensor);
679
680 strval = prop_string_value(obj);
681 obj = convert_val_to_pnumber(ksdict, "warning-max",
682 sensor, strval);
683 if (!prop_dictionary_set(csdict, "warning-max", obj))
684 err(EXIT_FAILURE, "prop_dict_set wmax");
685 }
686 /*
687 * warning-min property set?
688 */
689 obj = prop_dictionary_get(csdict, "warning-min");
690 if (obj) {
691 obj2 = prop_dictionary_get(ksdict, "monitoring-supported");
692 if (!prop_bool_true(obj2))
693 config_errmsg(PROP_ERR, "warning-min", sensor);
694
695 strval = prop_string_value(obj);
696 obj = convert_val_to_pnumber(ksdict, "warning-min",
697 sensor, strval);
698 if (!prop_dictionary_set(csdict, "warning-min", obj))
699 err(EXIT_FAILURE, "prop_dict_set wmin");
700 }
701 }
702
703 /*
704 * Conversions for {critical,warning}-{max,min} properties.
705 */
706 prop_number_t
convert_val_to_pnumber(prop_dictionary_t kdict,const char * prop,const char * sensor,const char * value)707 convert_val_to_pnumber(prop_dictionary_t kdict, const char *prop,
708 const char *sensor, const char *value)
709 {
710 prop_object_t obj;
711 prop_number_t num;
712 double val, max, min;
713 char *strval, *endptr;
714 bool celsius;
715 size_t len;
716
717 val = max = min = 0;
718
719 /*
720 * Not allowed in battery sensors.
721 */
722 obj = prop_dictionary_get(kdict, "type");
723 if (prop_string_equals_string(obj, "Battery capacity"))
724 config_errmsg(PROP_ERR, prop, sensor);
725
726 /*
727 * Make the conversion for sensor's type.
728 */
729 if (prop_string_equals_string(obj, "Temperature")) {
730 if (strchr(value, 'C'))
731 celsius = true;
732 else {
733 if (!strchr(value, 'F'))
734 config_errmsg(VALUE_ERR, prop, sensor);
735
736 celsius = false;
737 }
738
739 len = strlen(value);
740 strval = calloc(len, sizeof(*value));
741 if (!strval)
742 err(EXIT_FAILURE, "calloc");
743
744 (void)strlcpy(strval, value, len);
745 val = strtod(strval, &endptr);
746 if (*endptr != '\0') {
747 free(strval);
748 config_errmsg(VALUE_ERR, prop, sensor);
749 }
750
751 /* convert to fahrenheit */
752 if (!celsius)
753 val = (val - 32.0) * (5.0 / 9.0);
754
755 /* convert to microKelvin */
756 val = val * 1000000 + 273150000;
757 num = prop_number_create_unsigned(val);
758 free(strval);
759
760 } else if (prop_string_equals_string(obj, "Fan") ||
761 prop_string_equals_string(obj, "Integer")) {
762 /* no conversion */
763 val = strtod(value, &endptr);
764 if (*endptr != '\0')
765 config_errmsg(VALUE_ERR, prop, sensor);
766
767 num = prop_number_create_unsigned(val);
768
769 } else {
770 obj = prop_dictionary_get(kdict, "max-value");
771 if (obj)
772 max = prop_number_signed_value(obj);
773
774 obj = prop_dictionary_get(kdict, "min-value");
775 if (obj)
776 min = prop_number_signed_value(obj);
777
778 val = strtod(value, &endptr);
779 if (*endptr != '\0')
780 config_errmsg(VALUE_ERR, prop, sensor);
781
782 /* convert to m[V,W,Ohms] again */
783 val *= 1000000.0;
784
785 /*
786 * trying to set a value higher than the max
787 * assigned?
788 */
789 if (max && val > max)
790 config_errmsg(VALUE_ERR, prop, sensor);
791
792 /*
793 * trying to set a value lower than the min
794 * assigned?
795 */
796 if (min && val < min)
797 config_errmsg(VALUE_ERR, prop, sensor);
798
799 num = prop_number_create_signed(val);
800 }
801
802 return num;
803 }
804