Merge "Remove HAVE_LIBC_SYSTEM_PROPERTIES and HAVE_SYSTEM_PROPERTY_SERVER." (ec556521) · Commits · e / os / android_system_core

include/cutils/properties.h

+0 −16

Original line number	Diff line number	Diff line
		@@ -126,22 +126,6 @@ int property_get(const char key, char value, const char *default_value) {

		#endif

		#ifdef HAVE_SYSTEM_PROPERTY_SERVER
		/*
		* We have an external property server instead of built-in libc support.
		* Used by the simulator.
		*/
		#define SYSTEM_PROPERTY_PIPE_NAME "/tmp/android-sysprop"

		enum {
		kSystemPropertyUnknown = 0,
		kSystemPropertyGet,
		kSystemPropertySet,
		kSystemPropertyList
		};
		#endif /HAVE_SYSTEM_PROPERTY_SERVER/


		#ifdef __cplusplus
		}
		#endif

libcutils/properties.c

+2 −184

Original line number	Diff line number	Diff line
		@@ -104,7 +104,7 @@ 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
		#ifdef __BIONIC__

		#define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
		#include <sys/_system_properties.h>
		@@ -157,191 +157,9 @@ int property_list(
		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 */
		/* SUPER-cheesy place-holder implementation for glibc/Mac OS/Windows. */

		#include <cutils/threads.h>