ASR_BASE
Change-Id: Icf3719cc0afe3eeb3edc7fa80a2eb5199ca9dda1
diff --git a/package/utils/adbd/src/libcutils/properties.c b/package/utils/adbd/src/libcutils/properties.c
new file mode 100644
index 0000000..864e2e4
--- /dev/null
+++ b/package/utils/adbd/src/libcutils/properties.c
@@ -0,0 +1,424 @@
+/*
+ * 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"
+// #define LOG_NDEBUG 0
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <cutils/sockets.h>
+#include <errno.h>
+#include <assert.h>
+
+#include <inttypes.h>
+#include <cutils/properties.h>
+#include <stdbool.h>
+#include <inttypes.h>
+#include "loghack.h"
+
+int8_t property_get_bool(const char *key, int8_t default_value) {
+ if (!key) {
+ return default_value;
+ }
+
+ int8_t result = default_value;
+ char buf[PROPERTY_VALUE_MAX] = {'\0',};
+
+ int len = property_get(key, buf, "");
+ if (len == 1) {
+ char ch = buf[0];
+ if (ch == '0' || ch == 'n') {
+ result = false;
+ } else if (ch == '1' || ch == 'y') {
+ result = true;
+ }
+ } else if (len > 1) {
+ if (!strcmp(buf, "no") || !strcmp(buf, "false") || !strcmp(buf, "off")) {
+ result = false;
+ } else if (!strcmp(buf, "yes") || !strcmp(buf, "true") || !strcmp(buf, "on")) {
+ result = true;
+ }
+ }
+
+ return result;
+}
+
+// Convert string property to int (default if fails); return default value if out of bounds
+static intmax_t property_get_imax(const char *key, intmax_t lower_bound, intmax_t upper_bound,
+ intmax_t default_value) {
+ if (!key) {
+ return default_value;
+ }
+
+ intmax_t result = default_value;
+ char buf[PROPERTY_VALUE_MAX] = {'\0',};
+ char *end = NULL;
+
+ int len = property_get(key, buf, "");
+ if (len > 0) {
+ int tmp = errno;
+ errno = 0;
+
+ // Infer base automatically
+ result = strtoimax(buf, &end, /*base*/0);
+ if ((result == INTMAX_MIN || result == INTMAX_MAX) && errno == ERANGE) {
+ // Over or underflow
+ result = default_value;
+ ALOGV("%s(%s,%" PRIdMAX ") - overflow", __FUNCTION__, key, default_value);
+ } else if (result < lower_bound || result > upper_bound) {
+ // Out of range of requested bounds
+ result = default_value;
+ ALOGV("%s(%s,%" PRIdMAX ") - out of range", __FUNCTION__, key, default_value);
+ } else if (end == buf) {
+ // Numeric conversion failed
+ result = default_value;
+ ALOGV("%s(%s,%" PRIdMAX ") - numeric conversion failed",
+ __FUNCTION__, key, default_value);
+ }
+
+ errno = tmp;
+ }
+
+ return result;
+}
+
+int64_t property_get_int64(const char *key, int64_t default_value) {
+ return (int64_t)property_get_imax(key, INT64_MIN, INT64_MAX, default_value);
+}
+
+int32_t property_get_int32(const char *key, int32_t default_value) {
+ return (int32_t)property_get_imax(key, INT32_MIN, INT32_MAX, default_value);
+}
+
+#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);
+ if (len >= PROPERTY_VALUE_MAX) {
+ len = PROPERTY_VALUE_MAX - 1;
+ }
+ memcpy(value, default_value, len);
+ value[len] = '\0';
+ }
+ 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;
+ return 0;
+}
+
+
+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;
+ return 0;
+}
+
+
+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;
+ return 0;
+}
+
+int property_list(void (*propfn)(const char *key, const char *value, void *cookie),
+ void *cookie)
+{
+ return 0;
+}
+
+#endif