blob: 41cdb41fad2a216d27c65234f113cd4d1b4c354a [file] [log] [blame]
/*
* Copyright (C) 2008 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.
*/
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define LOG_TAG "PropertyManager"
#include <cutils/log.h>
#include "PropertyManager.h"
PropertyManager::PropertyManager() {
mNamespaces = new PropertyNamespaceCollection();
pthread_mutex_init(&mLock, NULL);
}
PropertyManager::~PropertyManager() {
PropertyNamespaceCollection::iterator it;
for (it = mNamespaces->begin(); it != mNamespaces->end();) {
delete (*it);
it = mNamespaces->erase(it);
}
delete mNamespaces;
}
PropertyNamespace *PropertyManager::lookupNamespace_UNLOCKED(const char *ns) {
PropertyNamespaceCollection::iterator ns_it;
for (ns_it = mNamespaces->begin(); ns_it != mNamespaces->end(); ++ns_it) {
if (!strcasecmp(ns, (*ns_it)->getName()))
return (*ns_it);
}
errno = ENOENT;
return NULL;
}
Property *PropertyManager::lookupProperty_UNLOCKED(PropertyNamespace *ns, const char *name) {
PropertyCollection::iterator it;
for (it = ns->getProperties()->begin();
it != ns->getProperties()->end(); ++it) {
if (!strcasecmp(name, (*it)->getName()))
return (*it);
}
errno = ENOENT;
return NULL;
}
int PropertyManager::attachProperty(const char *ns_name, Property *p) {
PropertyNamespace *ns;
ALOGD("Attaching property %s to namespace %s", p->getName(), ns_name);
pthread_mutex_lock(&mLock);
if (!(ns = lookupNamespace_UNLOCKED(ns_name))) {
ALOGD("Creating namespace %s", ns_name);
ns = new PropertyNamespace(ns_name);
mNamespaces->push_back(ns);
}
if (lookupProperty_UNLOCKED(ns, p->getName())) {
errno = EADDRINUSE;
pthread_mutex_unlock(&mLock);
ALOGE("Failed to register property %s.%s (%s)",
ns_name, p->getName(), strerror(errno));
return -1;
}
ns->getProperties()->push_back(p);
pthread_mutex_unlock(&mLock);
return 0;
}
int PropertyManager::detachProperty(const char *ns_name, Property *p) {
PropertyNamespace *ns;
ALOGD("Detaching property %s from namespace %s", p->getName(), ns_name);
pthread_mutex_lock(&mLock);
if (!(ns = lookupNamespace_UNLOCKED(ns_name))) {
pthread_mutex_unlock(&mLock);
ALOGE("Namespace '%s' not found", ns_name);
return -1;
}
PropertyCollection::iterator it;
for (it = ns->getProperties()->begin();
it != ns->getProperties()->end(); ++it) {
if (!strcasecmp(p->getName(), (*it)->getName())) {
delete ((*it));
ns->getProperties()->erase(it);
pthread_mutex_unlock(&mLock);
return 0;
}
}
ALOGE("Property %s.%s not found", ns_name, p->getName());
pthread_mutex_unlock(&mLock);
errno = ENOENT;
return -1;
}
int PropertyManager::doSet(Property *p, int idx, const char *value) {
if (p->getReadOnly()) {
errno = EROFS;
return -1;
}
if (p->getType() == Property::Type_STRING) {
return p->set(idx, value);
} else if (p->getType() == Property::Type_INTEGER) {
int tmp;
errno = 0;
tmp = strtol(value, (char **) NULL, 10);
if (errno) {
ALOGE("Failed to convert '%s' to int", value);
errno = EINVAL;
return -1;
}
return p->set(idx, tmp);
} else if (p->getType() == Property::Type_IPV4) {
struct in_addr tmp;
if (!inet_aton(value, &tmp)) {
ALOGE("Failed to convert '%s' to ipv4", value);
errno = EINVAL;
return -1;
}
return p->set(idx, &tmp);
} else {
ALOGE("Property '%s' has an unknown type (%d)", p->getName(),
p->getType());
errno = EINVAL;
return -1;
}
errno = ENOENT;
return -1;
}
int PropertyManager::doGet(Property *p, int idx, char *buffer, size_t max) {
if (p->getType() == Property::Type_STRING) {
if (p->get(idx, buffer, max)) {
ALOGW("String property %s get failed (%s)", p->getName(),
strerror(errno));
return -1;
}
}
else if (p->getType() == Property::Type_INTEGER) {
int tmp;
if (p->get(idx, &tmp)) {
ALOGW("Integer property %s get failed (%s)", p->getName(),
strerror(errno));
return -1;
}
snprintf(buffer, max, "%d", tmp);
} else if (p->getType() == Property::Type_IPV4) {
struct in_addr tmp;
if (p->get(idx, &tmp)) {
ALOGW("IPV4 property %s get failed (%s)", p->getName(),
strerror(errno));
return -1;
}
strncpy(buffer, inet_ntoa(tmp), max);
} else {
ALOGE("Property '%s' has an unknown type (%d)", p->getName(),
p->getType());
errno = EINVAL;
return -1;
}
return 0;
}
/*
* IPropertyManager methods
*/
int PropertyManager::set(const char *name, const char *value) {
ALOGD("set %s = '%s'", name, value);
pthread_mutex_lock(&mLock);
PropertyNamespaceCollection::iterator ns_it;
for (ns_it = mNamespaces->begin(); ns_it != mNamespaces->end(); ++ns_it) {
PropertyCollection::iterator p_it;
for (p_it = (*ns_it)->getProperties()->begin();
p_it != (*ns_it)->getProperties()->end(); ++p_it) {
for (int i = 0; i < (*p_it)->getNumElements(); i++) {
char fqn[255];
char tmp[8];
sprintf(tmp, "_%d", i);
snprintf(fqn, sizeof(fqn), "%s.%s%s",
(*ns_it)->getName(), (*p_it)->getName(),
((*p_it)->getNumElements() > 1 ? tmp : ""));
if (!strcasecmp(name, fqn)) {
pthread_mutex_unlock(&mLock);
return doSet((*p_it), i, value);
}
}
}
}
ALOGE("Property %s not found", name);
pthread_mutex_unlock(&mLock);
errno = ENOENT;
return -1;
}
const char *PropertyManager::get(const char *name, char *buffer, size_t max) {
pthread_mutex_lock(&mLock);
PropertyNamespaceCollection::iterator ns_it;
for (ns_it = mNamespaces->begin(); ns_it != mNamespaces->end(); ++ns_it) {
PropertyCollection::iterator p_it;
for (p_it = (*ns_it)->getProperties()->begin();
p_it != (*ns_it)->getProperties()->end(); ++p_it) {
for (int i = 0; i < (*p_it)->getNumElements(); i++) {
char fqn[255];
char tmp[8];
sprintf(tmp, "_%d", i);
snprintf(fqn, sizeof(fqn), "%s.%s%s",
(*ns_it)->getName(), (*p_it)->getName(),
((*p_it)->getNumElements() > 1 ? tmp : ""));
if (!strcasecmp(name, fqn)) {
pthread_mutex_unlock(&mLock);
if (doGet((*p_it), i, buffer, max))
return NULL;
return buffer;
}
}
}
}
ALOGE("Property %s not found", name);
pthread_mutex_unlock(&mLock);
errno = ENOENT;
return NULL;
}
android::List<char *> *PropertyManager::createPropertyList(const char *prefix) {
android::List<char *> *c = new android::List<char *>();
pthread_mutex_lock(&mLock);
PropertyNamespaceCollection::iterator ns_it;
for (ns_it = mNamespaces->begin(); ns_it != mNamespaces->end(); ++ns_it) {
PropertyCollection::iterator p_it;
for (p_it = (*ns_it)->getProperties()->begin();
p_it != (*ns_it)->getProperties()->end(); ++p_it) {
for (int i = 0; i < (*p_it)->getNumElements(); i++) {
char fqn[255];
char tmp[8];
sprintf(tmp, "_%d", i);
snprintf(fqn, sizeof(fqn), "%s.%s%s",
(*ns_it)->getName(), (*p_it)->getName(),
((*p_it)->getNumElements() > 1 ? tmp : ""));
if (!prefix ||
(prefix && !strncasecmp(fqn, prefix, strlen(prefix)))) {
c->push_back(strdup(fqn));
}
}
}
}
pthread_mutex_unlock(&mLock);
return c;
}