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
19#include <stdlib.h>
20#include <string.h>
21#include <unistd.h>
22#include <cutils/sockets.h>
23#include <errno.h>
24#include <assert.h>
25
26#include <cutils/properties.h>
27#include "loghack.h"
28
29#ifdef HAVE_LIBC_SYSTEM_PROPERTIES
30
31#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
32#include <sys/_system_properties.h>
33
34int property_set(const char *key, const char *value)
35{
36    return __system_property_set(key, value);
37}
38
39int property_get(const char *key, char *value, const char *default_value)
40{
41    int len;
42
43    len = __system_property_get(key, value);
44    if(len > 0) {
45        return len;
46    }
47
48    if(default_value) {
49        len = strlen(default_value);
50        memcpy(value, default_value, len + 1);
51    }
52    return len;
53}
54
55int property_list(void (*propfn)(const char *key, const char *value, void *cookie),
56                  void *cookie)
57{
58    char name[PROP_NAME_MAX];
59    char value[PROP_VALUE_MAX];
60    const prop_info *pi;
61    unsigned n;
62
63    for(n = 0; (pi = __system_property_find_nth(n)); n++) {
64        __system_property_read(pi, name, value);
65        propfn(name, value, cookie);
66    }
67    return 0;
68}
69
70#elif defined(HAVE_SYSTEM_PROPERTY_SERVER)
71
72/*
73 * The Linux simulator provides a "system property server" that uses IPC
74 * to set/get/list properties.  The file descriptor is shared by all
75 * threads in the process, so we use a mutex to ensure that requests
76 * from multiple threads don't get interleaved.
77 */
78#include <stdio.h>
79#include <sys/types.h>
80#include <sys/socket.h>
81#include <sys/un.h>
82#include <pthread.h>
83
84static pthread_once_t gInitOnce = PTHREAD_ONCE_INIT;
85static pthread_mutex_t gPropertyFdLock = PTHREAD_MUTEX_INITIALIZER;
86static int gPropFd = -1;
87
88/*
89 * Connect to the properties server.
90 *
91 * Returns the socket descriptor on success.
92 */
93static int connectToServer(const char* fileName)
94{
95    int sock = -1;
96    int cc;
97
98    struct sockaddr_un addr;
99
100    sock = socket(AF_UNIX, SOCK_STREAM, 0);
101    if (sock < 0) {
102        ALOGW("UNIX domain socket create failed (errno=%d)\n", errno);
103        return -1;
104    }
105
106    /* connect to socket; fails if file doesn't exist */
107    strcpy(addr.sun_path, fileName);    // max 108 bytes
108    addr.sun_family = AF_UNIX;
109    cc = connect(sock, (struct sockaddr*) &addr, SUN_LEN(&addr));
110    if (cc < 0) {
111        // ENOENT means socket file doesn't exist
112        // ECONNREFUSED means socket exists but nobody is listening
113        //ALOGW("AF_UNIX connect failed for '%s': %s\n",
114        //    fileName, strerror(errno));
115        close(sock);
116        return -1;
117    }
118
119    return sock;
120}
121
122/*
123 * Perform one-time initialization.
124 */
125static void init(void)
126{
127    assert(gPropFd == -1);
128
129    gPropFd = connectToServer(SYSTEM_PROPERTY_PIPE_NAME);
130    if (gPropFd < 0) {
131        //ALOGW("not connected to system property server\n");
132    } else {
133        //ALOGV("Connected to system property server\n");
134    }
135}
136
137int property_get(const char *key, char *value, const char *default_value)
138{
139    char sendBuf[1+PROPERTY_KEY_MAX];
140    char recvBuf[1+PROPERTY_VALUE_MAX];
141    int len = -1;
142
143    //ALOGV("PROPERTY GET [%s]\n", key);
144
145    pthread_once(&gInitOnce, init);
146    if (gPropFd < 0) {
147        /* this mimics the behavior of the device implementation */
148        if (default_value != NULL) {
149            strcpy(value, default_value);
150            len = strlen(value);
151        }
152        return len;
153    }
154
155    if (strlen(key) >= PROPERTY_KEY_MAX) return -1;
156
157    memset(sendBuf, 0xdd, sizeof(sendBuf));    // placate valgrind
158
159    sendBuf[0] = (char) kSystemPropertyGet;
160    strcpy(sendBuf+1, key);
161
162    pthread_mutex_lock(&gPropertyFdLock);
163    if (write(gPropFd, sendBuf, sizeof(sendBuf)) != sizeof(sendBuf)) {
164        pthread_mutex_unlock(&gPropertyFdLock);
165        return -1;
166    }
167    if (read(gPropFd, recvBuf, sizeof(recvBuf)) != sizeof(recvBuf)) {
168        pthread_mutex_unlock(&gPropertyFdLock);
169        return -1;
170    }
171    pthread_mutex_unlock(&gPropertyFdLock);
172
173    /* first byte is 0 if value not defined, 1 if found */
174    if (recvBuf[0] == 0) {
175        if (default_value != NULL) {
176            strcpy(value, default_value);
177            len = strlen(value);
178        } else {
179            /*
180             * If the value isn't defined, hand back an empty string and
181             * a zero length, rather than a failure.  This seems wrong,
182             * since you can't tell the difference between "undefined" and
183             * "defined but empty", but it's what the device does.
184             */
185            value[0] = '\0';
186            len = 0;
187        }
188    } else if (recvBuf[0] == 1) {
189        strcpy(value, recvBuf+1);
190        len = strlen(value);
191    } else {
192        ALOGE("Got strange response to property_get request (%d)\n",
193            recvBuf[0]);
194        assert(0);
195        return -1;
196    }
197    //ALOGV("PROP [found=%d def='%s'] (%d) [%s]: [%s]\n",
198    //    recvBuf[0], default_value, len, key, value);
199
200    return len;
201}
202
203
204int property_set(const char *key, const char *value)
205{
206    char sendBuf[1+PROPERTY_KEY_MAX+PROPERTY_VALUE_MAX];
207    char recvBuf[1];
208    int result = -1;
209
210    //ALOGV("PROPERTY SET [%s]: [%s]\n", key, value);
211
212    pthread_once(&gInitOnce, init);
213    if (gPropFd < 0)
214        return -1;
215
216    if (strlen(key) >= PROPERTY_KEY_MAX) return -1;
217    if (strlen(value) >= PROPERTY_VALUE_MAX) return -1;
218
219    memset(sendBuf, 0xdd, sizeof(sendBuf));    // placate valgrind
220
221    sendBuf[0] = (char) kSystemPropertySet;
222    strcpy(sendBuf+1, key);
223    strcpy(sendBuf+1+PROPERTY_KEY_MAX, value);
224
225    pthread_mutex_lock(&gPropertyFdLock);
226    if (write(gPropFd, sendBuf, sizeof(sendBuf)) != sizeof(sendBuf)) {
227        pthread_mutex_unlock(&gPropertyFdLock);
228        return -1;
229    }
230    if (read(gPropFd, recvBuf, sizeof(recvBuf)) != sizeof(recvBuf)) {
231        pthread_mutex_unlock(&gPropertyFdLock);
232        return -1;
233    }
234    pthread_mutex_unlock(&gPropertyFdLock);
235
236    if (recvBuf[0] != 1)
237        return -1;
238    return 0;
239}
240
241int property_list(void (*propfn)(const char *key, const char *value, void *cookie),
242                  void *cookie)
243{
244    //ALOGV("PROPERTY LIST\n");
245    pthread_once(&gInitOnce, init);
246    if (gPropFd < 0)
247        return -1;
248
249    return 0;
250}
251
252#else
253
254/* SUPER-cheesy place-holder implementation for Win32 */
255
256#include <cutils/threads.h>
257
258static mutex_t  env_lock = MUTEX_INITIALIZER;
259
260int property_get(const char *key, char *value, const char *default_value)
261{
262    char ename[PROPERTY_KEY_MAX + 6];
263    char *p;
264    int len;
265
266    len = strlen(key);
267    if(len >= PROPERTY_KEY_MAX) return -1;
268    memcpy(ename, "PROP_", 5);
269    memcpy(ename + 5, key, len + 1);
270
271    mutex_lock(&env_lock);
272
273    p = getenv(ename);
274    if(p == 0) p = "";
275    len = strlen(p);
276    if(len >= PROPERTY_VALUE_MAX) {
277        len = PROPERTY_VALUE_MAX - 1;
278    }
279
280    if((len == 0) && default_value) {
281        len = strlen(default_value);
282        memcpy(value, default_value, len + 1);
283    } else {
284        memcpy(value, p, len);
285        value[len] = 0;
286    }
287
288    mutex_unlock(&env_lock);
289
290    return len;
291}
292
293
294int property_set(const char *key, const char *value)
295{
296    char ename[PROPERTY_KEY_MAX + 6];
297    char *p;
298    int len;
299    int r;
300
301    if(strlen(value) >= PROPERTY_VALUE_MAX) return -1;
302
303    len = strlen(key);
304    if(len >= PROPERTY_KEY_MAX) return -1;
305    memcpy(ename, "PROP_", 5);
306    memcpy(ename + 5, key, len + 1);
307
308    mutex_lock(&env_lock);
309#ifdef HAVE_MS_C_RUNTIME
310    {
311        char  temp[256];
312        snprintf( temp, sizeof(temp), "%s=%s", ename, value);
313        putenv(temp);
314        r = 0;
315    }
316#else
317    r = setenv(ename, value, 1);
318#endif
319    mutex_unlock(&env_lock);
320
321    return r;
322}
323
324int property_list(void (*propfn)(const char *key, const char *value, void *cookie),
325                  void *cookie)
326{
327    return 0;
328}
329
330#endif
331