int __system_property_get(const char *name, char *value) { const prop_info *pi = __system_property_find(name); if (pi != 0) { return __system_property_read(pi, 0, value); } else { value[0] = 0; return 0; } }
static void refresh_cache_property(struct cache_property* cache, const char* key) { if (!cache->cache.pinfo) { cache->cache.pinfo = __system_property_find(key); if (!cache->cache.pinfo) { return; } } cache->cache.serial = __system_property_serial(cache->cache.pinfo); __system_property_read(cache->cache.pinfo, 0, cache->property); }
static void print_sys_prop(const struct prop_info *pi, void *cookies) { char key[PROP_NAME_MAX]; char name[PROP_VALUE_MAX]; unsigned int serial; int valuelen; serial = __system_property_serial(pi); valuelen = __system_property_read(pi, key, name); if (valuelen < 1 || valuelen > PROP_VALUE_MAX) return; klog_write(6, "<6> [+%3u]%-32s = %s\n", (serial & 0xffffff) >> 1, key, name); }
int property_list(void (*propfn)(const char *key, const char *value, void *cookie), void *cookie) { char name[PROP_NAME_MAX]; char value[PROP_VALUE_MAX]; const prop_info *pi; unsigned n; for(n = 0; (pi = __system_property_find_nth(n)); n++) { __system_property_read(pi, name, value); propfn(name, value, cookie); } return 0; }
int wifi_stop_supplicant() { char supp_status[PROPERTY_VALUE_MAX] = {'\0'}; int count = 50; /* wait at most 5 seconds for completion */ #ifdef HAVE_LIBC_SYSTEM_PROPERTIES char supp_rdy_status[PROPERTY_VALUE_MAX] = ""; const prop_info *rdy_pi = NULL; int rdy_loop_count = 0; #endif /* Check whether supplicant already stopped */ if (property_get(supplicant_prop_name, supp_status, NULL) && strcmp(supp_status, "stopped") == 0) { return 0; } #ifdef HAVE_LIBC_SYSTEM_PROPERTIES /* Wait for the supplicant to deinitialize and set the property (SUPP_RDY_PROP_NAME) to 0 before killing the supplicant */ for (rdy_loop_count = 0; rdy_loop_count < 15000/RDY_WAIT_MS; rdy_loop_count ++) { if (rdy_pi == NULL) { rdy_pi = __system_property_find(SUPP_RDY_PROP_NAME); } else { __system_property_read(rdy_pi, NULL, supp_rdy_status); if (strcmp(supp_rdy_status, "0") == 0) { break; } } usleep (RDY_WAIT_MS * 1000); } #endif property_set("ctl.stop", supplicant_name); sched_yield(); while (count-- > 0) { if (property_get(supplicant_prop_name, supp_status, NULL)) { if (strcmp(supp_status, "stopped") == 0) return 0; } usleep(100000); } return -1; }
static void refresh_cache(struct cache *cache, const char *key) { uint32_t serial; char buf[PROP_VALUE_MAX]; if (!cache->pinfo) { cache->pinfo = __system_property_find(key); if (!cache->pinfo) { return; } } serial = __system_property_serial(cache->pinfo); if (serial == cache->serial) { return; } cache->serial = serial; __system_property_read(cache->pinfo, 0, buf); cache->c = buf[0]; }
static void refresh_cache(struct cache_char* cache, const char* key) { char buf[PROP_VALUE_MAX]; if (!cache->cache.pinfo) { cache->cache.pinfo = __system_property_find(key); if (!cache->cache.pinfo) { return; } } cache->cache.serial = __system_property_serial(cache->cache.pinfo); __system_property_read(cache->cache.pinfo, 0, buf); switch(buf[0]) { case 't': case 'T': cache->c = strcasecmp(buf + 1, "rue") ? buf[0] : BOOLEAN_TRUE; break; case 'f': case 'F': cache->c = strcasecmp(buf + 1, "alse") ? buf[0] : BOOLEAN_FALSE; break; default: cache->c = buf[0]; } }
static void hierarchical_test_callback(const prop_info *pi, void *cookie) { bool (*ok)[8][8] = static_cast<bool (*)[8][8]>(cookie); char name[PROP_NAME_MAX]; char value[PROP_VALUE_MAX]; __system_property_read(pi, name, value); int name_i, name_j, name_k; int value_i, value_j, value_k; ASSERT_EQ(3, sscanf(name, "property_%d.%d.%d", &name_i, &name_j, &name_k)); ASSERT_EQ(3, sscanf(value, "value_%d.%d.%d", &value_i, &value_j, &value_k)); ASSERT_EQ(name_i, value_i); ASSERT_GE(name_i, 0); ASSERT_LT(name_i, 8); ASSERT_EQ(name_j, value_j); ASSERT_GE(name_j, 0); ASSERT_LT(name_j, 8); ASSERT_EQ(name_k, value_k); ASSERT_GE(name_k, 0); ASSERT_LT(name_k, 8); ok[name_i][name_j][name_k] = true; }
int getprop_main(const struct cmd_getprop_info* info) { const char* format = info->getprop.format; const char* format_not_found = info->getprop.format_not_found; bool null = info->getprop.null; if (null && format == NULL && format_not_found == NULL) usage_error("must supply --format or " "--format-not-found or both if using -0"); find_symbol_in_libc("__system_property_foreach", &property_foreach); if (property_foreach == NULL) property_foreach = compat_property_foreach; dbg("using %s for property enumeration", property_foreach == compat_property_foreach ? "compat_property_foreach" : "__system_property_foreach"); int exit_status = 0; struct json_writer* writer = NULL; if (format == NULL && format_not_found == NULL) { writer = json_writer_create(xstdout); json_begin_object(writer); } const char** properties = ARGV_CONCAT(info->properties); bool first = true; char sep = null ? '\0' : '\n'; if (*properties == NULL) { struct property_vector* pv = find_all_properties(); char prev_name[PROP_NAME_MAX]; for (size_t i = 0; i < pv->size; ++i) { char name[PROP_NAME_MAX]; char value[PROP_VALUE_MAX]; (void) __system_property_read(pv->props[i], name, value); if (i > 0 && strcmp(name, prev_name) == 0) continue; if (writer != NULL) { json_begin_field(writer, name); json_emit_string(writer, value); } else { output_property(&first, sep, format, name, value); } strcpy(prev_name, name); } } else { size_t nproperties = argv_count(properties); qsort(properties, nproperties, sizeof (properties[0]), property_argv_compare); const char* property; const char* prev_property = NULL; while ((property = *properties++)) { if (prev_property != NULL && !strcmp(prev_property, property)) continue; if (writer != NULL) json_begin_field(writer, property); const prop_info* pi = __system_property_find(property); if (pi) { char value[PROP_VALUE_MAX]; __system_property_read(pi, NULL, value); if (writer != NULL) json_emit_string(writer, value); else if (format != NULL) output_property(&first, sep, format, property, value); } else { if (writer != NULL) json_emit_null(writer); else if (format_not_found != NULL) output_property(&first, sep, format_not_found, property, NULL); exit_status = 4; } prev_property = property; } } if (writer == NULL && !first && !null) xputc(sep, xstdout); if (writer != NULL) json_end_object(writer); xflush(xstdout); return exit_status; }
int wifi_start_supplicant(int p2p_supported) { char supp_status[PROPERTY_VALUE_MAX] = {'\0'}; int count = 200; /* wait at most 20 seconds for completion */ #ifdef HAVE_LIBC_SYSTEM_PROPERTIES const prop_info *pi; unsigned serial = 0, i; #endif if (p2p_supported) { strcpy(supplicant_name, P2P_SUPPLICANT_NAME); strcpy(supplicant_prop_name, P2P_PROP_NAME); /* Ensure p2p config file is created */ if (ensure_config_file_exists(P2P_CONFIG_FILE) < 0) { ALOGE("Failed to create a p2p config file"); return -1; } } else { strcpy(supplicant_name, SUPPLICANT_NAME); strcpy(supplicant_prop_name, SUPP_PROP_NAME); } /* Check whether already running */ if (property_get(supplicant_prop_name, supp_status, NULL) && strcmp(supp_status, "running") == 0) { return 0; } /* Before starting the daemon, make sure its config file exists */ if (ensure_config_file_exists(SUPP_CONFIG_FILE) < 0) { ALOGE("Wi-Fi will not be enabled"); return -1; } if (ensure_entropy_file_exists() < 0) { ALOGE("Wi-Fi entropy file was not created"); } /* Clear out any stale socket files that might be left over. */ wpa_ctrl_cleanup(); /* Reset sockets used for exiting from hung state */ exit_sockets[0] = exit_sockets[1] = -1; #ifdef HAVE_LIBC_SYSTEM_PROPERTIES /* * Get a reference to the status property, so we can distinguish * the case where it goes stopped => running => stopped (i.e., * it start up, but fails right away) from the case in which * it starts in the stopped state and never manages to start * running at all. */ pi = __system_property_find(supplicant_prop_name); if (pi != NULL) { serial = __system_property_serial(pi); } #endif property_get("wifi.interface", primary_iface, WIFI_TEST_INTERFACE); property_set("ctl.start", supplicant_name); sched_yield(); while (count-- > 0) { #ifdef HAVE_LIBC_SYSTEM_PROPERTIES if (pi == NULL) { pi = __system_property_find(supplicant_prop_name); } if (pi != NULL) { /* * property serial updated means that init process is scheduled * after we sched_yield, further property status checking is based on this */ if (__system_property_serial(pi) != serial) { __system_property_read(pi, NULL, supp_status); if (strcmp(supp_status, "running") == 0) { return 0; } else if (strcmp(supp_status, "stopped") == 0) { return -1; } } } #else if (property_get(supplicant_prop_name, supp_status, NULL)) { if (strcmp(supp_status, "running") == 0) return 0; } #endif usleep(100000); } return -1; }
int wifi_start_supplicant_common(const char *config_file) { char daemon_cmd[PROPERTY_VALUE_MAX]; char supp_status[PROPERTY_VALUE_MAX] = {'\0'}; int count = 200; /* wait at most 20 seconds for completion */ #ifdef HAVE_LIBC_SYSTEM_PROPERTIES const prop_info *pi; unsigned serial = 0; #endif /* Check whether already running */ if (property_get(SUPP_PROP_NAME, supp_status, NULL) && strcmp(supp_status, "running") == 0) { return 0; } /* Before starting the daemon, make sure its config file exists */ if (ensure_config_file_exists(config_file) < 0) { LOGE("Wi-Fi will not be enabled"); return -1; } if (ensure_entropy_file_exists() < 0) { LOGE("Wi-Fi entropy file was not created"); } /* Clear out any stale socket files that might be left over. */ wifi_wpa_ctrl_cleanup(); #ifdef HAVE_LIBC_SYSTEM_PROPERTIES /* * Get a reference to the status property, so we can distinguish * the case where it goes stopped => running => stopped (i.e., * it start up, but fails right away) from the case in which * it starts in the stopped state and never manages to start * running at all. */ pi = __system_property_find(SUPP_PROP_NAME); if (pi != NULL) { serial = pi->serial; } #endif property_get("wifi.interface", iface, WIFI_TEST_INTERFACE); snprintf(daemon_cmd, PROPERTY_VALUE_MAX, "%s:-i%s -c%s", SUPPLICANT_NAME, iface, config_file); property_set("ctl.start", daemon_cmd); sched_yield(); while (count-- > 0) { #ifdef HAVE_LIBC_SYSTEM_PROPERTIES if (pi == NULL) { pi = __system_property_find(SUPP_PROP_NAME); } if (pi != NULL) { __system_property_read(pi, NULL, supp_status); if (strcmp(supp_status, "running") == 0) { return 0; } else if (pi->serial != serial && strcmp(supp_status, "stopped") == 0) { return -1; } } #else if (property_get(SUPP_PROP_NAME, supp_status, NULL)) { if (strcmp(supp_status, "running") == 0) return 0; } #endif usleep(100000); } return -1; }
int start_supplicant(const struct _SUPPLICANT_PARA_T * prTar, const char *pcIface) { char daemon_cmd[PROPERTY_VALUE_MAX]; char supp_status[PROPERTY_VALUE_MAX] = {'\0'}; int count = 200; /* wait at most 20 seconds for completion */ #ifdef HAVE_LIBC_SYSTEM_PROPERTIES const prop_info *pi; unsigned serial = 0; #endif /* Check whether already running */ if (property_get(prTar->acSuppPropName, supp_status, NULL) && strcmp(supp_status, "running") == 0) { return 0; } /* Before starting the daemon, make sure its config file exists */ if (ensure_config_file_exists(prTar->acSuppConfigFile, prTar->acSuppConfigTemplate) < 0) { LOGE("[%s] %s will not be enabled", pcIface, prTar->acSuppName); return -1; } /*Set interface UP (ifconfig "iface" up)*/ if(set_iface(pcIface, 1) < 0 ) { /*If interface up failed, skip the following actions*/ return -1; } /* Clear out any stale socket files that might be left over. */ LOGD("[%s] clear out stale sockets with prefix \"%s\" in %s", pcIface, prTar->acSuppCtrlPrefix, CONFIG_CTRL_IFACE_CLIENT_DIR); ctrl_cleanup(prTar->acSuppCtrlPrefix); LOGI("[%s] start %s", pcIface, prTar->acSuppName); #ifdef HAVE_LIBC_SYSTEM_PROPERTIES /* * Get a reference to the status property, so we can distinguish * the case where it goes stopped => running => stopped (i.e., * it start up, but fails right away) from the case in which * it starts in the stopped state and never manages to start * running at all. */ pi = __system_property_find(prTar->acSuppPropName); if (pi != NULL) { serial = pi->serial; } #endif property_get(prTar->acIfPropName, (char *)pcIface, prTar->acIfDefName); snprintf(daemon_cmd, PROPERTY_VALUE_MAX, prTar->acSuppDeamonCmd, prTar->acSuppName, pcIface, prTar->acSuppConfigFile); property_set("ctl.start", daemon_cmd); LOGD("[%s] supplicant start command: \"%s\"", pcIface, daemon_cmd); //property_set("ctl.start", prTar->acSuppName); sched_yield(); while (count-- > 0) { #ifdef HAVE_LIBC_SYSTEM_PROPERTIES if (pi == NULL) { pi = __system_property_find(prTar->acSuppPropName); } if (pi != NULL) { __system_property_read(pi, NULL, supp_status); if (strcmp(supp_status, "running") == 0) { return 0; } else if (pi->serial != serial && strcmp(supp_status, "stopped") == 0) { return -1; } } #else if (property_get(prTar->acSuppPropName, supp_status, NULL)) { if (strcmp(supp_status, "running") == 0) return 0; } #endif usleep(100000); } return -1; }
int wifi_start_supplicant() { char supp_status[PROPERTY_VALUE_MAX] = {'\0'}; int count = 200; /* wait at most 20 seconds for completion */ #ifdef HAVE_LIBC_SYSTEM_PROPERTIES const prop_info *pi; unsigned serial = 0; #endif /* Check whether already running */ if (property_get(SUPP_PROP_NAME, supp_status, NULL) && strcmp(supp_status, "running") == 0) { return 0; } /* Before starting the daemon, make sure its config file exists */ if (ensure_config_file_exists() < 0) { LOGE("Wi-Fi will not be enabled"); return -1; } /* Clear out any stale socket files that might be left over. */ wpa_ctrl_cleanup(); #ifdef HAVE_LIBC_SYSTEM_PROPERTIES /* * Get a reference to the status property, so we can distinguish * the case where it goes stopped => running => stopped (i.e., * it start up, but fails right away) from the case in which * it starts in the stopped state and never manages to start * running at all. */ pi = __system_property_find(SUPP_PROP_NAME); if (pi != NULL) { serial = pi->serial; } #endif /* The ar6k driver needs the interface up in order to scan! */ if (!strncmp(DRIVER_MODULE_NAME, "ar6000", 6)) { ifc_init(); ifc_up("wlan0"); sleep(1); } property_set("ctl.start", SUPPLICANT_NAME); sched_yield(); while (count-- > 0) { #ifdef HAVE_LIBC_SYSTEM_PROPERTIES if (pi == NULL) { pi = __system_property_find(SUPP_PROP_NAME); } if (pi != NULL) { __system_property_read(pi, NULL, supp_status); if (strcmp(supp_status, "running") == 0) { return 0; } else if (pi->serial != serial && strcmp(supp_status, "stopped") == 0) { return -1; } } #else if (property_get(SUPP_PROP_NAME, supp_status, NULL)) { if (strcmp(supp_status, "running") == 0) return 0; } #endif usleep(100000); } return -1; }