| // |
| // Copyright 2007 The Android Open Source Project |
| // |
| // Property sever. Mimics behavior provided on the device by init(8) and |
| // some code built into libc. |
| // |
| |
| // For compilers that support precompilation, include "wx/wx.h". |
| #include "wx/wxprec.h" |
| |
| // Otherwise, include all standard headers |
| #ifndef WX_PRECOMP |
| # include "wx/wx.h" |
| #endif |
| #include "wx/image.h" |
| |
| #include "PropertyServer.h" |
| #include "MyApp.h" |
| #include "Preferences.h" |
| #include "MainFrame.h" |
| #include "utils.h" |
| |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <assert.h> |
| #include <sys/types.h> |
| #include <sys/socket.h> |
| #include <sys/stat.h> |
| #include <sys/un.h> |
| |
| |
| using namespace android; |
| |
| const char* PropertyServer::kPropCheckJni = "ro.kernel.android.checkjni"; |
| |
| /* |
| * Destructor. |
| */ |
| PropertyServer::~PropertyServer(void) |
| { |
| if (IsRunning()) { |
| // TODO: cause thread to stop, then Wait for it |
| } |
| printf("Sim: in ~PropertyServer()\n"); |
| } |
| |
| /* |
| * Create and run the thread. |
| */ |
| bool PropertyServer::StartThread(void) |
| { |
| if (Create() != wxTHREAD_NO_ERROR) { |
| fprintf(stderr, "Sim: ERROR: can't create PropertyServer thread\n"); |
| return false; |
| } |
| |
| Run(); |
| return true; |
| } |
| |
| |
| /* |
| * Clear out the list. |
| */ |
| void PropertyServer::ClearProperties(void) |
| { |
| typedef List<Property>::iterator PropIter; |
| |
| for (PropIter pi = mPropList.begin(); pi != mPropList.end(); ++pi) { |
| pi = mPropList.erase(pi); |
| } |
| } |
| |
| /* |
| * Set default values for several properties. |
| */ |
| void PropertyServer::SetDefaultProperties(void) |
| { |
| static const struct { |
| const char* key; |
| const char* value; |
| } propList[] = { |
| { "net.bt.name", "Android" }, |
| { "ro.kernel.mem", "60M" }, |
| { "ro.kernel.board_sardine.version", "4" }, |
| { "ro.kernel.console", "null" }, |
| { "ro.build.id", "engineering" }, |
| { "ro.build.date", "Wed Nov 28 07:44:14 PST 2007" }, |
| { "ro.build.date.utc", "1196264654" }, |
| { "ro.build.type", "eng" }, |
| { "ro.product.device", "simulator" /*"sooner"*/ }, |
| { "ro.product.brand", "generic" }, |
| { "ro.build.user", "fadden" }, |
| { "ro.build.host", "marathon" }, |
| { "ro.config.nocheckin", "yes" }, |
| { "ro.product.manufacturer", "" }, |
| { "ro.radio.use-ppp", "no" }, |
| { "ro.FOREGROUND_APP_ADJ", "0" }, |
| { "ro.VISIBLE_APP_ADJ", "1" }, |
| { "ro.SECONDARY_SERVER_ADJ", "2" }, |
| { "ro.HIDDEN_APP_MIN_ADJ", "7" }, |
| { "ro.CONTENT_PROVIDER_ADJ", "14" }, |
| { "ro.EMPTY_APP_ADJ", "15" }, |
| { "ro.FOREGROUND_APP_MEM", "1536" }, |
| { "ro.VISIBLE_APP_MEM", "2048" }, |
| { "ro.SECONDARY_SERVER_MEM", "4096" }, |
| { "ro.HIDDEN_APP_MEM", "8192" }, |
| { "ro.EMPTY_APP_MEM", "16384" }, |
| { "ro.HOME_APP_ADJ", "4" }, |
| { "ro.HOME_APP_MEM", "4096" }, |
| { "ro.BACKUP_APP_ADJ", "2" }, |
| { "ro.BACKUP_APP_MEM", "4096" }, |
| { "ro.PERCEPTIBLE_APP_ADJ", "2" }, |
| { "ro.PERCEPTIBLE_APP_MEM", "4096" }, |
| { "ro.HEAVY_WEIGHT_APP_ADJ", "3" }, |
| { "ro.HEAVY_WEIGHT_APP_MEM", "4096" }, |
| //{ "init.svc.adbd", "running" }, // causes ADB-JDWP |
| { "init.svc.usbd", "running" }, |
| { "init.svc.debuggerd", "running" }, |
| { "init.svc.ril-daemon", "running" }, |
| { "init.svc.zygote", "running" }, |
| { "init.svc.runtime", "running" }, |
| { "init.svc.dbus", "running" }, |
| { "init.svc.pppd_gprs", "running" }, |
| { "adb.connected", "0" }, |
| /* |
| { "status.battery.state", "Slow" }, |
| { "status.battery.level", "5" }, |
| { "status.battery.level_raw", "50" }, |
| { "status.battery.level_scale", "9" }, |
| */ |
| |
| /* disable the annoying setup wizard */ |
| { "app.setupwizard.disable", "1" }, |
| |
| /* Dalvik options, set by AndroidRuntime */ |
| { "dalvik.vm.stack-trace-file", "/data/anr/traces.txt" }, |
| //{ "dalvik.vm.execution-mode", "int:portable" }, |
| { "dalvik.vm.enableassertions", "all" }, // -ea |
| { "dalvik.vm.dexopt-flags", "" }, // e.g. "v=a,o=v,m=n" |
| { "dalvik.vm.deadlock-predict", "off" }, // -Xdeadlockpredict |
| //{ "dalvik.vm.jniopts", "forcecopy" }, // -Xjniopts |
| { "log.redirect-stdio", "false" }, // -Xlog-stdio |
| |
| /* SurfaceFlinger options */ |
| { "debug.sf.nobootanimation", "1" }, |
| { "debug.sf.showupdates", "0" }, |
| { "debug.sf.showcpu", "0" }, |
| { "debug.sf.showbackground", "0" }, |
| { "debug.sf.showfps", "0" }, |
| { "default", "default" }, |
| |
| /* Stagefright options */ |
| { "media.stagefright.enable-player", "true" }, |
| { "media.stagefright.enable-meta", "true" }, |
| { "media.stagefright.enable-scan", "true" }, |
| { "media.stagefright.enable-http", "true" }, |
| }; |
| |
| for (int i = 0; i < NELEM(propList); i++) |
| SetProperty(propList[i].key, propList[i].value); |
| |
| Preferences* pPrefs = ((MyApp*)wxTheApp)->GetPrefs(); |
| bool doCheckJni = false; |
| |
| pPrefs->GetBool("check-jni", &doCheckJni); |
| if (doCheckJni) |
| SetProperty(kPropCheckJni, "1"); |
| else |
| SetProperty(kPropCheckJni, "0"); |
| } |
| |
| /* |
| * Get the value of a property. |
| * |
| * "valueBuf" must hold at least PROPERTY_VALUE_MAX bytes. |
| * |
| * Returns "true" if the property was found. |
| */ |
| bool PropertyServer::GetProperty(const char* key, char* valueBuf) |
| { |
| typedef List<Property>::iterator PropIter; |
| |
| assert(key != NULL); |
| assert(valueBuf != NULL); |
| |
| for (PropIter pi = mPropList.begin(); pi != mPropList.end(); ++pi) { |
| Property& prop = *pi; |
| if (strcmp(prop.key, key) == 0) { |
| if (strlen(prop.value) >= PROPERTY_VALUE_MAX) { |
| fprintf(stderr, |
| "GLITCH: properties table holds '%s' '%s' (len=%d)\n", |
| prop.key, prop.value, (int) strlen(prop.value)); |
| abort(); |
| } |
| assert(strlen(prop.value) < PROPERTY_VALUE_MAX); |
| strcpy(valueBuf, prop.value); |
| return true; |
| } |
| } |
| |
| //printf("Prop: get [%s] not found\n", key); |
| return false; |
| } |
| |
| /* |
| * Set the value of a property, replacing it if it already exists. |
| * |
| * If "value" is NULL, the property is removed. |
| * |
| * If the property is immutable, this returns "false" without doing |
| * anything. (Not implemented.) |
| */ |
| bool PropertyServer::SetProperty(const char* key, const char* value) |
| { |
| typedef List<Property>::iterator PropIter; |
| |
| assert(key != NULL); |
| assert(value != NULL); |
| |
| for (PropIter pi = mPropList.begin(); pi != mPropList.end(); ++pi) { |
| Property& prop = *pi; |
| if (strcmp(prop.key, key) == 0) { |
| if (value != NULL) { |
| //printf("Prop: replacing [%s]: [%s] with [%s]\n", |
| // prop.key, prop.value, value); |
| strcpy(prop.value, value); |
| } else { |
| //printf("Prop: removing [%s]\n", prop.key); |
| mPropList.erase(pi); |
| } |
| return true; |
| } |
| } |
| |
| //printf("Prop: adding [%s]: [%s]\n", key, value); |
| Property tmp; |
| strcpy(tmp.key, key); |
| strcpy(tmp.value, value); |
| mPropList.push_back(tmp); |
| return true; |
| } |
| |
| /* |
| * Create a UNIX domain socket, carefully removing it if it already |
| * exists. |
| */ |
| bool PropertyServer::CreateSocket(const char* fileName) |
| { |
| struct stat sb; |
| bool result = false; |
| int sock = -1; |
| int cc; |
| |
| cc = stat(fileName, &sb); |
| if (cc < 0) { |
| if (errno != ENOENT) { |
| LOG(LOG_ERROR, "sim-prop", |
| "Unable to stat '%s' (errno=%d)\n", fileName, errno); |
| goto bail; |
| } |
| } else { |
| /* don't touch it if it's not a socket */ |
| if (!(S_ISSOCK(sb.st_mode))) { |
| LOG(LOG_ERROR, "sim-prop", |
| "File '%s' exists and is not a socket\n", fileName); |
| goto bail; |
| } |
| |
| /* remove the cruft */ |
| if (unlink(fileName) < 0) { |
| LOG(LOG_ERROR, "sim-prop", |
| "Unable to remove '%s' (errno=%d)\n", fileName, errno); |
| goto bail; |
| } |
| } |
| |
| struct sockaddr_un addr; |
| |
| sock = ::socket(AF_UNIX, SOCK_STREAM, 0); |
| if (sock < 0) { |
| LOG(LOG_ERROR, "sim-prop", |
| "UNIX domain socket create failed (errno=%d)\n", errno); |
| goto bail; |
| } |
| |
| /* bind the socket; this creates the file on disk */ |
| strcpy(addr.sun_path, fileName); // max 108 bytes |
| addr.sun_family = AF_UNIX; |
| cc = ::bind(sock, (struct sockaddr*) &addr, SUN_LEN(&addr)); |
| if (cc < 0) { |
| LOG(LOG_ERROR, "sim", |
| "AF_UNIX bind failed for '%s' (errno=%d)\n", fileName, errno); |
| goto bail; |
| } |
| |
| cc = ::listen(sock, 5); |
| if (cc < 0) { |
| LOG(LOG_ERROR, "sim", "AF_UNIX listen failed (errno=%d)\n", errno); |
| goto bail; |
| } |
| |
| mListenSock = sock; |
| sock = -1; |
| result = true; |
| |
| bail: |
| if (sock >= 0) |
| close(sock); |
| return result; |
| } |
| |
| /* |
| * Handle a client request. |
| * |
| * Returns true on success, false if the fd should be closed. |
| */ |
| bool PropertyServer::HandleRequest(int fd) |
| { |
| char reqBuf[PROPERTY_KEY_MAX + PROPERTY_VALUE_MAX]; |
| char valueBuf[1 + PROPERTY_VALUE_MAX]; |
| ssize_t actual; |
| |
| memset(valueBuf, 'x', sizeof(valueBuf)); // placate valgrind |
| |
| /* read the command byte; this determines the message length */ |
| actual = read(fd, reqBuf, 1); |
| if (actual <= 0) |
| return false; |
| |
| if (reqBuf[0] == kSystemPropertyGet) { |
| actual = read(fd, reqBuf, PROPERTY_KEY_MAX); |
| |
| if (actual != PROPERTY_KEY_MAX) { |
| fprintf(stderr, "Bad read on get: %d of %d\n", |
| (int) actual, PROPERTY_KEY_MAX); |
| return false; |
| } |
| if (GetProperty(reqBuf, valueBuf+1)) |
| valueBuf[0] = 1; |
| else |
| valueBuf[0] = 0; |
| //printf("GET property [%s]: (found=%d) [%s]\n", |
| // reqBuf, valueBuf[0], valueBuf+1); |
| if (write(fd, valueBuf, sizeof(valueBuf)) != sizeof(valueBuf)) { |
| fprintf(stderr, "Bad write on get\n"); |
| return false; |
| } |
| } else if (reqBuf[0] == kSystemPropertySet) { |
| actual = read(fd, reqBuf, PROPERTY_KEY_MAX + PROPERTY_VALUE_MAX); |
| if (actual != PROPERTY_KEY_MAX + PROPERTY_VALUE_MAX) { |
| fprintf(stderr, "Bad read on set: %d of %d\n", |
| (int) actual, PROPERTY_KEY_MAX + PROPERTY_VALUE_MAX); |
| return false; |
| } |
| //printf("SET property '%s'\n", reqBuf); |
| if (SetProperty(reqBuf, reqBuf + PROPERTY_KEY_MAX)) |
| valueBuf[0] = 1; |
| else |
| valueBuf[0] = 0; |
| if (write(fd, valueBuf, 1) != 1) { |
| fprintf(stderr, "Bad write on set\n"); |
| return false; |
| } |
| } else if (reqBuf[0] == kSystemPropertyList) { |
| /* TODO */ |
| assert(false); |
| } else { |
| fprintf(stderr, "Unexpected request %d from prop client\n", reqBuf[0]); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /* |
| * Serve up properties. |
| */ |
| void PropertyServer::ServeProperties(void) |
| { |
| typedef List<int>::iterator IntIter; |
| fd_set readfds; |
| int maxfd; |
| |
| while (true) { |
| int cc; |
| |
| FD_ZERO(&readfds); |
| FD_SET(mListenSock, &readfds); |
| maxfd = mListenSock; |
| |
| for (IntIter ii = mClientList.begin(); ii != mClientList.end(); ++ii) { |
| int fd = (*ii); |
| |
| FD_SET(fd, &readfds); |
| if (maxfd < fd) |
| maxfd = fd; |
| } |
| |
| cc = select(maxfd+1, &readfds, NULL, NULL, NULL); |
| if (cc < 0) { |
| if (errno == EINTR) { |
| printf("hiccup!\n"); |
| continue; |
| } |
| return; |
| } |
| if (FD_ISSET(mListenSock, &readfds)) { |
| struct sockaddr_un from; |
| socklen_t fromlen; |
| int newSock; |
| |
| fromlen = sizeof(from); |
| newSock = ::accept(mListenSock, (struct sockaddr*) &from, &fromlen); |
| if (newSock < 0) { |
| LOG(LOG_WARN, "sim", |
| "AF_UNIX accept failed (errno=%d)\n", errno); |
| } else { |
| //printf("new props connection on %d --> %d\n", |
| // mListenSock, newSock); |
| |
| mClientList.push_back(newSock); |
| } |
| } |
| |
| for (IntIter ii = mClientList.begin(); ii != mClientList.end(); ) { |
| int fd = (*ii); |
| bool ok = true; |
| |
| if (FD_ISSET(fd, &readfds)) { |
| //printf("--- activity on %d\n", fd); |
| |
| ok = HandleRequest(fd); |
| } |
| |
| if (ok) { |
| ++ii; |
| } else { |
| //printf("--- closing %d\n", fd); |
| close(fd); |
| ii = mClientList.erase(ii); |
| } |
| } |
| } |
| } |
| |
| /* |
| * Thread entry point. |
| * |
| * This just sits and waits for a new connection. It hands it off to the |
| * main thread and then goes back to waiting. |
| * |
| * There is currently no "polite" way to shut this down. |
| */ |
| void* PropertyServer::Entry(void) |
| { |
| if (CreateSocket(SYSTEM_PROPERTY_PIPE_NAME)) { |
| assert(mListenSock >= 0); |
| SetDefaultProperties(); |
| |
| /* loop until it's time to exit or we fail */ |
| ServeProperties(); |
| |
| ClearProperties(); |
| |
| /* |
| * Close listen socket and all clients. |
| */ |
| LOG(LOG_INFO, "sim", "Cleaning up socket list\n"); |
| typedef List<int>::iterator IntIter; |
| for (IntIter ii = mClientList.begin(); ii != mClientList.end(); ++ii) |
| close((*ii)); |
| close(mListenSock); |
| } |
| |
| LOG(LOG_INFO, "sim", "PropertyServer thread exiting\n"); |
| return NULL; |
| } |
| |