1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "properties"
18// #define LOG_NDEBUG 0
19
20#include <stdlib.h>
21#include <string.h>
22#include <ctype.h>
23#include <unistd.h>
24#include <cutils/sockets.h>
25#include <errno.h>
26#include <assert.h>
27
28#include <cutils/properties.h>
29#include <stdbool.h>
30#include <inttypes.h>
31#include <log/log.h>
32
33int8_t property_get_bool(const char *key, int8_t default_value) {
34    if (!key) {
35        return default_value;
36    }
37
38    int8_t result = default_value;
39    char buf[PROPERTY_VALUE_MAX] = {'\0',};
40
41    int len = property_get(key, buf, "");
42    if (len == 1) {
43        char ch = buf[0];
44        if (ch == '0' || ch == 'n') {
45            result = false;
46        } else if (ch == '1' || ch == 'y') {
47            result = true;
48        }
49    } else if (len > 1) {
50         if (!strcmp(buf, "no") || !strcmp(buf, "false") || !strcmp(buf, "off")) {
51            result = false;
52        } else if (!strcmp(buf, "yes") || !strcmp(buf, "true") || !strcmp(buf, "on")) {
53            result = true;
54        }
55    }
56
57    return result;
58}
59
60// Convert string property to int (default if fails); return default value if out of bounds
61static intmax_t property_get_imax(const char *key, intmax_t lower_bound, intmax_t upper_bound,
62        intmax_t default_value) {
63    if (!key) {
64        return default_value;
65    }
66
67    intmax_t result = default_value;
68    char buf[PROPERTY_VALUE_MAX] = {'\0',};
69    char *end = NULL;
70
71    int len = property_get(key, buf, "");
72    if (len > 0) {
73        int tmp = errno;
74        errno = 0;
75
76        // Infer base automatically
77        result = strtoimax(buf, &end, /*base*/0);
78        if ((result == INTMAX_MIN || result == INTMAX_MAX) && errno == ERANGE) {
79            // Over or underflow
80            result = default_value;
81            ALOGV("%s(%s,%" PRIdMAX ") - overflow", __FUNCTION__, key, default_value);
82        } else if (result < lower_bound || result > upper_bound) {
83            // Out of range of requested bounds
84            result = default_value;
85            ALOGV("%s(%s,%" PRIdMAX ") - out of range", __FUNCTION__, key, default_value);
86        } else if (end == buf) {
87            // Numeric conversion failed
88            result = default_value;
89            ALOGV("%s(%s,%" PRIdMAX ") - numeric conversion failed",
90                    __FUNCTION__, key, default_value);
91        }
92
93        errno = tmp;
94    }
95
96    return result;
97}
98
99int64_t property_get_int64(const char *key, int64_t default_value) {
100    return (int64_t)property_get_imax(key, INT64_MIN, INT64_MAX, default_value);
101}
102
103int32_t property_get_int32(const char *key, int32_t default_value) {
104    return (int32_t)property_get_imax(key, INT32_MIN, INT32_MAX, default_value);
105}
106
107#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
108#include <sys/_system_properties.h>
109
110int property_set(const char *key, const char *value)
111{
112    return __system_property_set(key, value);
113}
114
115int property_get(const char *key, char *value, const char *default_value)
116{
117    int len;
118
119    len = __system_property_get(key, value);
120    if(len > 0) {
121        return len;
122    }
123    if(default_value) {
124        len = strlen(default_value);
125        if (len >= PROPERTY_VALUE_MAX) {
126            len = PROPERTY_VALUE_MAX - 1;
127        }
128        memcpy(value, default_value, len);
129        value[len] = '\0';
130    }
131    return len;
132}
133
134struct property_list_callback_data
135{
136    void (*propfn)(const char *key, const char *value, void *cookie);
137    void *cookie;
138};
139
140static void property_list_callback(const prop_info *pi, void *cookie)
141{
142    char name[PROP_NAME_MAX];
143    char value[PROP_VALUE_MAX];
144    struct property_list_callback_data *data = cookie;
145
146    __system_property_read(pi, name, value);
147    data->propfn(name, value, data->cookie);
148}
149
150int property_list(
151        void (*propfn)(const char *key, const char *value, void *cookie),
152        void *cookie)
153{
154    struct property_list_callback_data data = { propfn, cookie };
155    return __system_property_foreach(property_list_callback, &data);
156}
157