6967935eb3
Signed-off-by: Greg Hackmann <ghackmann@google.com>
(cherry picked from commit e7bb159d16)
Change-Id: I0f66144eb8a4a48e04e4fcd125ad37f19ad94b8e
339 lines
8.5 KiB
C
339 lines
8.5 KiB
C
/*
|
|
* Copyright (C) 2006 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define LOG_TAG "properties"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <cutils/sockets.h>
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
|
|
#include <cutils/properties.h>
|
|
#include "loghack.h"
|
|
|
|
#ifdef HAVE_LIBC_SYSTEM_PROPERTIES
|
|
|
|
#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
|
|
#include <sys/_system_properties.h>
|
|
|
|
int property_set(const char *key, const char *value)
|
|
{
|
|
return __system_property_set(key, value);
|
|
}
|
|
|
|
int property_get(const char *key, char *value, const char *default_value)
|
|
{
|
|
int len;
|
|
|
|
len = __system_property_get(key, value);
|
|
if(len > 0) {
|
|
return len;
|
|
}
|
|
|
|
if(default_value) {
|
|
len = strlen(default_value);
|
|
memcpy(value, default_value, len + 1);
|
|
}
|
|
return len;
|
|
}
|
|
|
|
struct property_list_callback_data
|
|
{
|
|
void (*propfn)(const char *key, const char *value, void *cookie);
|
|
void *cookie;
|
|
};
|
|
|
|
static void property_list_callback(const prop_info *pi, void *cookie)
|
|
{
|
|
char name[PROP_NAME_MAX];
|
|
char value[PROP_VALUE_MAX];
|
|
struct property_list_callback_data *data = cookie;
|
|
|
|
__system_property_read(pi, name, value);
|
|
data->propfn(name, value, data->cookie);
|
|
}
|
|
|
|
int property_list(
|
|
void (*propfn)(const char *key, const char *value, void *cookie),
|
|
void *cookie)
|
|
{
|
|
struct property_list_callback_data data = { propfn, cookie };
|
|
return __system_property_foreach(property_list_callback, &data);
|
|
}
|
|
|
|
#elif defined(HAVE_SYSTEM_PROPERTY_SERVER)
|
|
|
|
/*
|
|
* The Linux simulator provides a "system property server" that uses IPC
|
|
* to set/get/list properties. The file descriptor is shared by all
|
|
* threads in the process, so we use a mutex to ensure that requests
|
|
* from multiple threads don't get interleaved.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <pthread.h>
|
|
|
|
static pthread_once_t gInitOnce = PTHREAD_ONCE_INIT;
|
|
static pthread_mutex_t gPropertyFdLock = PTHREAD_MUTEX_INITIALIZER;
|
|
static int gPropFd = -1;
|
|
|
|
/*
|
|
* Connect to the properties server.
|
|
*
|
|
* Returns the socket descriptor on success.
|
|
*/
|
|
static int connectToServer(const char* fileName)
|
|
{
|
|
int sock = -1;
|
|
int cc;
|
|
|
|
struct sockaddr_un addr;
|
|
|
|
sock = socket(AF_UNIX, SOCK_STREAM, 0);
|
|
if (sock < 0) {
|
|
ALOGW("UNIX domain socket create failed (errno=%d)\n", errno);
|
|
return -1;
|
|
}
|
|
|
|
/* connect to socket; fails if file doesn't exist */
|
|
strcpy(addr.sun_path, fileName); // max 108 bytes
|
|
addr.sun_family = AF_UNIX;
|
|
cc = connect(sock, (struct sockaddr*) &addr, SUN_LEN(&addr));
|
|
if (cc < 0) {
|
|
// ENOENT means socket file doesn't exist
|
|
// ECONNREFUSED means socket exists but nobody is listening
|
|
//ALOGW("AF_UNIX connect failed for '%s': %s\n",
|
|
// fileName, strerror(errno));
|
|
close(sock);
|
|
return -1;
|
|
}
|
|
|
|
return sock;
|
|
}
|
|
|
|
/*
|
|
* Perform one-time initialization.
|
|
*/
|
|
static void init(void)
|
|
{
|
|
assert(gPropFd == -1);
|
|
|
|
gPropFd = connectToServer(SYSTEM_PROPERTY_PIPE_NAME);
|
|
if (gPropFd < 0) {
|
|
//ALOGW("not connected to system property server\n");
|
|
} else {
|
|
//ALOGV("Connected to system property server\n");
|
|
}
|
|
}
|
|
|
|
int property_get(const char *key, char *value, const char *default_value)
|
|
{
|
|
char sendBuf[1+PROPERTY_KEY_MAX];
|
|
char recvBuf[1+PROPERTY_VALUE_MAX];
|
|
int len = -1;
|
|
|
|
//ALOGV("PROPERTY GET [%s]\n", key);
|
|
|
|
pthread_once(&gInitOnce, init);
|
|
if (gPropFd < 0) {
|
|
/* this mimics the behavior of the device implementation */
|
|
if (default_value != NULL) {
|
|
strcpy(value, default_value);
|
|
len = strlen(value);
|
|
}
|
|
return len;
|
|
}
|
|
|
|
if (strlen(key) >= PROPERTY_KEY_MAX) return -1;
|
|
|
|
memset(sendBuf, 0xdd, sizeof(sendBuf)); // placate valgrind
|
|
|
|
sendBuf[0] = (char) kSystemPropertyGet;
|
|
strcpy(sendBuf+1, key);
|
|
|
|
pthread_mutex_lock(&gPropertyFdLock);
|
|
if (write(gPropFd, sendBuf, sizeof(sendBuf)) != sizeof(sendBuf)) {
|
|
pthread_mutex_unlock(&gPropertyFdLock);
|
|
return -1;
|
|
}
|
|
if (read(gPropFd, recvBuf, sizeof(recvBuf)) != sizeof(recvBuf)) {
|
|
pthread_mutex_unlock(&gPropertyFdLock);
|
|
return -1;
|
|
}
|
|
pthread_mutex_unlock(&gPropertyFdLock);
|
|
|
|
/* first byte is 0 if value not defined, 1 if found */
|
|
if (recvBuf[0] == 0) {
|
|
if (default_value != NULL) {
|
|
strcpy(value, default_value);
|
|
len = strlen(value);
|
|
} else {
|
|
/*
|
|
* If the value isn't defined, hand back an empty string and
|
|
* a zero length, rather than a failure. This seems wrong,
|
|
* since you can't tell the difference between "undefined" and
|
|
* "defined but empty", but it's what the device does.
|
|
*/
|
|
value[0] = '\0';
|
|
len = 0;
|
|
}
|
|
} else if (recvBuf[0] == 1) {
|
|
strcpy(value, recvBuf+1);
|
|
len = strlen(value);
|
|
} else {
|
|
ALOGE("Got strange response to property_get request (%d)\n",
|
|
recvBuf[0]);
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
//ALOGV("PROP [found=%d def='%s'] (%d) [%s]: [%s]\n",
|
|
// recvBuf[0], default_value, len, key, value);
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
int property_set(const char *key, const char *value)
|
|
{
|
|
char sendBuf[1+PROPERTY_KEY_MAX+PROPERTY_VALUE_MAX];
|
|
char recvBuf[1];
|
|
int result = -1;
|
|
|
|
//ALOGV("PROPERTY SET [%s]: [%s]\n", key, value);
|
|
|
|
pthread_once(&gInitOnce, init);
|
|
if (gPropFd < 0)
|
|
return -1;
|
|
|
|
if (strlen(key) >= PROPERTY_KEY_MAX) return -1;
|
|
if (strlen(value) >= PROPERTY_VALUE_MAX) return -1;
|
|
|
|
memset(sendBuf, 0xdd, sizeof(sendBuf)); // placate valgrind
|
|
|
|
sendBuf[0] = (char) kSystemPropertySet;
|
|
strcpy(sendBuf+1, key);
|
|
strcpy(sendBuf+1+PROPERTY_KEY_MAX, value);
|
|
|
|
pthread_mutex_lock(&gPropertyFdLock);
|
|
if (write(gPropFd, sendBuf, sizeof(sendBuf)) != sizeof(sendBuf)) {
|
|
pthread_mutex_unlock(&gPropertyFdLock);
|
|
return -1;
|
|
}
|
|
if (read(gPropFd, recvBuf, sizeof(recvBuf)) != sizeof(recvBuf)) {
|
|
pthread_mutex_unlock(&gPropertyFdLock);
|
|
return -1;
|
|
}
|
|
pthread_mutex_unlock(&gPropertyFdLock);
|
|
|
|
if (recvBuf[0] != 1)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
int property_list(void (*propfn)(const char *key, const char *value, void *cookie),
|
|
void *cookie)
|
|
{
|
|
//ALOGV("PROPERTY LIST\n");
|
|
pthread_once(&gInitOnce, init);
|
|
if (gPropFd < 0)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
|
|
/* SUPER-cheesy place-holder implementation for Win32 */
|
|
|
|
#include <cutils/threads.h>
|
|
|
|
static mutex_t env_lock = MUTEX_INITIALIZER;
|
|
|
|
int property_get(const char *key, char *value, const char *default_value)
|
|
{
|
|
char ename[PROPERTY_KEY_MAX + 6];
|
|
char *p;
|
|
int len;
|
|
|
|
len = strlen(key);
|
|
if(len >= PROPERTY_KEY_MAX) return -1;
|
|
memcpy(ename, "PROP_", 5);
|
|
memcpy(ename + 5, key, len + 1);
|
|
|
|
mutex_lock(&env_lock);
|
|
|
|
p = getenv(ename);
|
|
if(p == 0) p = "";
|
|
len = strlen(p);
|
|
if(len >= PROPERTY_VALUE_MAX) {
|
|
len = PROPERTY_VALUE_MAX - 1;
|
|
}
|
|
|
|
if((len == 0) && default_value) {
|
|
len = strlen(default_value);
|
|
memcpy(value, default_value, len + 1);
|
|
} else {
|
|
memcpy(value, p, len);
|
|
value[len] = 0;
|
|
}
|
|
|
|
mutex_unlock(&env_lock);
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
int property_set(const char *key, const char *value)
|
|
{
|
|
char ename[PROPERTY_KEY_MAX + 6];
|
|
char *p;
|
|
int len;
|
|
int r;
|
|
|
|
if(strlen(value) >= PROPERTY_VALUE_MAX) return -1;
|
|
|
|
len = strlen(key);
|
|
if(len >= PROPERTY_KEY_MAX) return -1;
|
|
memcpy(ename, "PROP_", 5);
|
|
memcpy(ename + 5, key, len + 1);
|
|
|
|
mutex_lock(&env_lock);
|
|
#ifdef HAVE_MS_C_RUNTIME
|
|
{
|
|
char temp[256];
|
|
snprintf( temp, sizeof(temp), "%s=%s", ename, value);
|
|
putenv(temp);
|
|
r = 0;
|
|
}
|
|
#else
|
|
r = setenv(ename, value, 1);
|
|
#endif
|
|
mutex_unlock(&env_lock);
|
|
|
|
return r;
|
|
}
|
|
|
|
int property_list(void (*propfn)(const char *key, const char *value, void *cookie),
|
|
void *cookie)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif
|