summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cmds/keystore/certtool.h16
-rw-r--r--cmds/keystore/keymgmt.c7
-rw-r--r--cmds/keystore/keymgmt.h3
-rw-r--r--cmds/keystore/keystore_get.h53
-rw-r--r--cmds/keystore/netkeystore.c1
-rw-r--r--include/utils/AssetManager.h11
-rw-r--r--include/utils/ResourceTypes.h1
-rw-r--r--libs/utils/Asset.cpp5
-rw-r--r--libs/utils/AssetManager.cpp97
-rw-r--r--libs/utils/ResourceTypes.cpp96
10 files changed, 243 insertions, 47 deletions
diff --git a/cmds/keystore/certtool.h b/cmds/keystore/certtool.h
index 7cd316b0fd..aefad668d1 100644
--- a/cmds/keystore/certtool.h
+++ b/cmds/keystore/certtool.h
@@ -26,21 +26,29 @@
#include "common.h"
#include "netkeystore.h"
+#define CERT_NAME_LEN (2 * MAX_KEY_NAME_LENGTH + 2)
+
/*
* The specific function 'get_cert' is used in daemons to get the key value
* from keystore. Caller should allocate the buffer and the length of the buffer
* should be MAX_KEY_VALUE_LENGTH.
*/
-static inline int get_cert(char *certname, unsigned char *value, int *size)
+static inline int get_cert(const char *certname, unsigned char *value, int *size)
{
int count, fd, ret = -1;
LPC_MARSHAL cmd;
char delimiter[] = "_";
char *namespace, *keyname;
char *context = NULL;
+ char cname[CERT_NAME_LEN];
+
+ if ((certname == NULL) || (value == NULL)) {
+ LOGE("get_cert: certname or value is null\n");
+ return -1;
+ }
- if (value == NULL) {
- LOGE("get_cert: value is null\n");
+ if (strlcpy(cname, certname, CERT_NAME_LEN) >= CERT_NAME_LEN) {
+ LOGE("get_cert: keyname is too long\n");
return -1;
}
@@ -53,7 +61,7 @@ static inline int get_cert(char *certname, unsigned char *value, int *size)
}
cmd.opcode = GET;
- if (((namespace = strtok_r(certname, delimiter, &context)) == NULL) ||
+ if (((namespace = strtok_r(cname, delimiter, &context)) == NULL) ||
((keyname = strtok_r(NULL, delimiter, &context)) == NULL)) {
goto err;
}
diff --git a/cmds/keystore/keymgmt.c b/cmds/keystore/keymgmt.c
index e4102a920e..66edd56616 100644
--- a/cmds/keystore/keymgmt.c
+++ b/cmds/keystore/keymgmt.c
@@ -185,6 +185,7 @@ static int change_passwd(char *data)
p = strtok_r(NULL, delimiter, &context);
}
if (count != 2) return -1;
+ if (strlen(new_pass) < MIN_PASSWD_LENGTH) return -1;
if ((ret = get_master_key(old_pass, master_key)) == 0) {
ret = store_master_key(new_pass, master_key);
retry_count = 0;
@@ -259,6 +260,11 @@ int list_keys(const char *namespace, char reply[BUFFER_MAX])
DIR *d;
struct dirent *de;
+ if (state != UNLOCKED) {
+ LOGE("Can not list key with current state %d\n", state);
+ return -1;
+ }
+
if (!namespace || ((d = opendir("."))) == NULL) {
LOGE("cannot open keystore dir or namespace is null\n");
return -1;
@@ -287,6 +293,7 @@ int passwd(char *data)
{
if (state == UNINITIALIZED) {
if (strchr(data, ' ')) return -1;
+ if (strlen(data) < MIN_PASSWD_LENGTH) return -1;
return create_master_key(data);
}
return change_passwd(data);
diff --git a/cmds/keystore/keymgmt.h b/cmds/keystore/keymgmt.h
index 0f1057042b..0e928db494 100644
--- a/cmds/keystore/keymgmt.h
+++ b/cmds/keystore/keymgmt.h
@@ -27,7 +27,8 @@
#define AES_KEY_LEN 128
#define USER_KEY_LEN (AES_KEY_LEN/8)
#define IV_LEN USER_KEY_LEN
-#define MAX_RETRY_COUNT 6
+#define MAX_RETRY_COUNT 6
+#define MIN_PASSWD_LENGTH 8
#define gen_key(passwd, key, len) \
PKCS5_PBKDF2_HMAC_SHA1(passwd, strlen(passwd), \
diff --git a/cmds/keystore/keystore_get.h b/cmds/keystore/keystore_get.h
new file mode 100644
index 0000000000..a7fd9a556a
--- /dev/null
+++ b/cmds/keystore/keystore_get.h
@@ -0,0 +1,53 @@
+/*
+**
+** Copyright 2009, 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.
+*/
+
+#ifndef __KEYSTORE_GET_H__
+#define __KEYSTORE_GET_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "certtool.h"
+
+/* This function is provided to native components to get values from keystore.
+ * Users are required to link against libcutils. If something goes wrong, NULL
+ * is returned. Otherwise it returns the value in dynamically allocated memory
+ * and sets the size if the pointer is not NULL. One can release the memory by
+ * calling free(). */
+static char *keystore_get(char *key, int *size)
+{
+ char buffer[MAX_KEY_VALUE_LENGTH];
+ char *value;
+ int length;
+
+ if (get_cert(key, (unsigned char *)buffer, &length) != 0) {
+ return NULL;
+ }
+ value = malloc(length + 1);
+ if (!value) {
+ return NULL;
+ }
+ memcpy(value, buffer, length);
+ value[length] = 0;
+ if (size) {
+ *size = length;
+ }
+ return value;
+}
+
+#endif
diff --git a/cmds/keystore/netkeystore.c b/cmds/keystore/netkeystore.c
index e45e24f687..eac455e0c5 100644
--- a/cmds/keystore/netkeystore.c
+++ b/cmds/keystore/netkeystore.c
@@ -224,6 +224,7 @@ static void do_reset_keystore(LPC_MARSHAL *cmd, LPC_MARSHAL *reply)
}
reply->retcode = reset_keystore();
}
+
static void execute(LPC_MARSHAL *cmd, LPC_MARSHAL *reply)
{
uint32_t cmd_max = sizeof(cmds)/sizeof(struct cmdinfo);
diff --git a/include/utils/AssetManager.h b/include/utils/AssetManager.h
index c11429eaf2..d8994e05a0 100644
--- a/include/utils/AssetManager.h
+++ b/include/utils/AssetManager.h
@@ -251,6 +251,9 @@ private:
Asset* getResourceTableAsset();
Asset* setResourceTableAsset(Asset* asset);
+ ResTable* getResourceTable();
+ ResTable* setResourceTable(ResTable* res);
+
bool isUpToDate();
protected:
@@ -265,6 +268,7 @@ private:
time_t mModWhen;
Asset* mResourceTableAsset;
+ ResTable* mResourceTable;
static Mutex gLock;
static DefaultKeyedVector<String8, wp<SharedZip> > gOpen;
@@ -288,8 +292,11 @@ private:
*/
ZipFileRO* getZip(const String8& path);
- Asset* getZipResourceTable(const String8& path);
- Asset* setZipResourceTable(const String8& path, Asset* asset);
+ Asset* getZipResourceTableAsset(const String8& path);
+ Asset* setZipResourceTableAsset(const String8& path, Asset* asset);
+
+ ResTable* getZipResourceTable(const String8& path);
+ ResTable* setZipResourceTable(const String8& path, ResTable* res);
// generate path, e.g. "common/en-US-noogle.zip"
static String8 getPathName(const char* path);
diff --git a/include/utils/ResourceTypes.h b/include/utils/ResourceTypes.h
index eb4151a1ac..93bca4aefc 100644
--- a/include/utils/ResourceTypes.h
+++ b/include/utils/ResourceTypes.h
@@ -1580,6 +1580,7 @@ public:
bool copyData=false);
status_t add(Asset* asset, void* cookie,
bool copyData=false);
+ status_t add(ResTable* src);
status_t getError() const;
diff --git a/libs/utils/Asset.cpp b/libs/utils/Asset.cpp
index 91203ddb45..23cb72d4ef 100644
--- a/libs/utils/Asset.cpp
+++ b/libs/utils/Asset.cpp
@@ -582,11 +582,14 @@ const void* _FileAsset::ensureAlignment(FileMap* map)
if ((((size_t)data)&0x3) == 0) {
// We can return this directly if it is aligned on a word
// boundary.
+ LOGV("Returning aligned FileAsset %p (%s).", this,
+ getAssetSource());
return data;
}
// If not aligned on a word boundary, then we need to copy it into
// our own buffer.
- LOGV("Copying FileAsset %p to buffer size %d to make it aligned.", this, (int)mLength);
+ LOGV("Copying FileAsset %p (%s) to buffer size %d to make it aligned.", this,
+ getAssetSource(), (int)mLength);
unsigned char* buf = new unsigned char[mLength];
if (buf == NULL) {
LOGE("alloc of %ld bytes failed\n", (long) mLength);
diff --git a/libs/utils/AssetManager.cpp b/libs/utils/AssetManager.cpp
index 4126bfb7a9..5a05e6a61f 100644
--- a/libs/utils/AssetManager.cpp
+++ b/libs/utils/AssetManager.cpp
@@ -395,21 +395,41 @@ const ResTable* AssetManager::getResTable(bool required) const
const size_t N = mAssetPaths.size();
for (size_t i=0; i<N; i++) {
Asset* ass = NULL;
+ ResTable* sharedRes = NULL;
bool shared = true;
const asset_path& ap = mAssetPaths.itemAt(i);
LOGV("Looking for resource asset in '%s'\n", ap.path.string());
if (ap.type != kFileTypeDirectory) {
- ass = const_cast<AssetManager*>(this)->
- mZipSet.getZipResourceTable(ap.path);
- if (ass == NULL) {
- LOGV("loading resource table %s\n", ap.path.string());
+ if (i == 0) {
+ // The first item is typically the framework resources,
+ // which we want to avoid parsing every time.
+ sharedRes = const_cast<AssetManager*>(this)->
+ mZipSet.getZipResourceTable(ap.path);
+ }
+ if (sharedRes == NULL) {
ass = const_cast<AssetManager*>(this)->
- openNonAssetInPathLocked("resources.arsc",
- Asset::ACCESS_BUFFER,
- ap);
- if (ass != NULL && ass != kExcludedAsset) {
+ mZipSet.getZipResourceTableAsset(ap.path);
+ if (ass == NULL) {
+ LOGV("loading resource table %s\n", ap.path.string());
ass = const_cast<AssetManager*>(this)->
- mZipSet.setZipResourceTable(ap.path, ass);
+ openNonAssetInPathLocked("resources.arsc",
+ Asset::ACCESS_BUFFER,
+ ap);
+ if (ass != NULL && ass != kExcludedAsset) {
+ ass = const_cast<AssetManager*>(this)->
+ mZipSet.setZipResourceTableAsset(ap.path, ass);
+ }
+ }
+
+ if (i == 0 && ass != NULL) {
+ // If this is the first resource table in the asset
+ // manager, then we are going to cache it so that we
+ // can quickly copy it out for others.
+ LOGV("Creating shared resources for %s", ap.path.string());
+ sharedRes = new ResTable();
+ sharedRes->add(ass, (void*)(i+1), false);
+ sharedRes = const_cast<AssetManager*>(this)->
+ mZipSet.setZipResourceTable(ap.path, sharedRes);
}
}
} else {
@@ -420,13 +440,19 @@ const ResTable* AssetManager::getResTable(bool required) const
ap);
shared = false;
}
- if (ass != NULL && ass != kExcludedAsset) {
+ if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) {
if (rt == NULL) {
mResources = rt = new ResTable();
updateResourceParamsLocked();
}
LOGV("Installing resource asset %p in to table %p\n", ass, mResources);
- rt->add(ass, (void*)(i+1), !shared);
+ if (sharedRes != NULL) {
+ LOGV("Copying existing resources for %s", ap.path.string());
+ rt->add(sharedRes);
+ } else {
+ LOGV("Parsing resources for %s", ap.path.string());
+ rt->add(ass, (void*)(i+1), !shared);
+ }
if (!shared) {
delete ass;
@@ -1510,7 +1536,8 @@ Mutex AssetManager::SharedZip::gLock;
DefaultKeyedVector<String8, wp<AssetManager::SharedZip> > AssetManager::SharedZip::gOpen;
AssetManager::SharedZip::SharedZip(const String8& path, time_t modWhen)
- : mPath(path), mZipFile(NULL), mModWhen(modWhen), mResourceTableAsset(NULL)
+ : mPath(path), mZipFile(NULL), mModWhen(modWhen),
+ mResourceTableAsset(NULL), mResourceTable(NULL)
{
//LOGI("Creating SharedZip %p %s\n", this, (const char*)mPath);
mZipFile = new ZipFileRO;
@@ -1563,6 +1590,25 @@ Asset* AssetManager::SharedZip::setResourceTableAsset(Asset* asset)
return mResourceTableAsset;
}
+ResTable* AssetManager::SharedZip::getResourceTable()
+{
+ LOGV("Getting from SharedZip %p resource table %p\n", this, mResourceTable);
+ return mResourceTable;
+}
+
+ResTable* AssetManager::SharedZip::setResourceTable(ResTable* res)
+{
+ {
+ AutoMutex _l(gLock);
+ if (mResourceTable == NULL) {
+ mResourceTable = res;
+ return res;
+ }
+ }
+ delete res;
+ return mResourceTable;
+}
+
bool AssetManager::SharedZip::isUpToDate()
{
time_t modWhen = getFileModDate(mPath.string());
@@ -1572,6 +1618,9 @@ bool AssetManager::SharedZip::isUpToDate()
AssetManager::SharedZip::~SharedZip()
{
//LOGI("Destroying SharedZip %p %s\n", this, (const char*)mPath);
+ if (mResourceTable != NULL) {
+ delete mResourceTable;
+ }
if (mResourceTableAsset != NULL) {
delete mResourceTableAsset;
}
@@ -1627,7 +1676,7 @@ ZipFileRO* AssetManager::ZipSet::getZip(const String8& path)
return zip->getZip();
}
-Asset* AssetManager::ZipSet::getZipResourceTable(const String8& path)
+Asset* AssetManager::ZipSet::getZipResourceTableAsset(const String8& path)
{
int idx = getIndex(path);
sp<SharedZip> zip = mZipFile[idx];
@@ -1638,7 +1687,7 @@ Asset* AssetManager::ZipSet::getZipResourceTable(const String8& path)
return zip->getResourceTableAsset();
}
-Asset* AssetManager::ZipSet::setZipResourceTable(const String8& path,
+Asset* AssetManager::ZipSet::setZipResourceTableAsset(const String8& path,
Asset* asset)
{
int idx = getIndex(path);
@@ -1647,6 +1696,26 @@ Asset* AssetManager::ZipSet::setZipResourceTable(const String8& path,
return zip->setResourceTableAsset(asset);
}
+ResTable* AssetManager::ZipSet::getZipResourceTable(const String8& path)
+{
+ int idx = getIndex(path);
+ sp<SharedZip> zip = mZipFile[idx];
+ if (zip == NULL) {
+ zip = SharedZip::get(path);
+ mZipFile.editItemAt(idx) = zip;
+ }
+ return zip->getResourceTable();
+}
+
+ResTable* AssetManager::ZipSet::setZipResourceTable(const String8& path,
+ ResTable* res)
+{
+ int idx = getIndex(path);
+ sp<SharedZip> zip = mZipFile[idx];
+ // doesn't make sense to call before previously accessing.
+ return zip->setResourceTable(res);
+}
+
/*
* Generate the partial pathname for the specified archive. The caller
* gets to prepend the asset root directory.
diff --git a/libs/utils/ResourceTypes.cpp b/libs/utils/ResourceTypes.cpp
index 4a5063a300..109f28d305 100644
--- a/libs/utils/ResourceTypes.cpp
+++ b/libs/utils/ResourceTypes.cpp
@@ -1136,8 +1136,9 @@ status_t ResXMLTree::validateNode(const ResXMLTree_node* node) const
struct ResTable::Header
{
- Header() : ownedData(NULL), header(NULL) { }
+ Header(ResTable* _owner) : owner(_owner), ownedData(NULL), header(NULL) { }
+ ResTable* const owner;
void* ownedData;
const ResTable_header* header;
size_t size;
@@ -1163,8 +1164,8 @@ struct ResTable::Type
struct ResTable::Package
{
- Package(const Header* _header, const ResTable_package* _package)
- : header(_header), package(_package) { }
+ Package(ResTable* _owner, const Header* _header, const ResTable_package* _package)
+ : owner(_owner), header(_header), package(_package) { }
~Package()
{
size_t i = types.size();
@@ -1174,10 +1175,14 @@ struct ResTable::Package
}
}
+ ResTable* const owner;
const Header* const header;
const ResTable_package* const package;
Vector<Type*> types;
+ ResStringPool typeStrings;
+ ResStringPool keyStrings;
+
const Type* getType(size_t idx) const {
return idx < types.size() ? types[idx] : NULL;
}
@@ -1188,13 +1193,16 @@ struct ResTable::Package
// table that defined the package); the ones after are skins on top of it.
struct ResTable::PackageGroup
{
- PackageGroup(const String16& _name, uint32_t _id)
- : name(_name), id(_id), typeCount(0), bags(NULL) { }
+ PackageGroup(ResTable* _owner, const String16& _name, uint32_t _id)
+ : owner(_owner), name(_name), id(_id), typeCount(0), bags(NULL) { }
~PackageGroup() {
clearBagCache();
const size_t N = packages.size();
for (size_t i=0; i<N; i++) {
- delete packages[i];
+ Package* pkg = packages[i];
+ if (pkg->owner == owner) {
+ delete pkg;
+ }
}
}
@@ -1225,15 +1233,17 @@ struct ResTable::PackageGroup
}
}
+ ResTable* const owner;
String16 const name;
uint32_t const id;
Vector<Package*> packages;
+
+ // This is for finding typeStrings and other common package stuff.
+ Package* basePackage;
- // Taken from the root package.
- ResStringPool typeStrings;
- ResStringPool keyStrings;
+ // For quick access.
size_t typeCount;
-
+
// Computed attribute bags, first indexed by the type and second
// by the entry in that type.
bag_set*** bags;
@@ -1560,11 +1570,36 @@ status_t ResTable::add(Asset* asset, void* cookie, bool copyData)
return add(data, size, cookie, asset, copyData);
}
+status_t ResTable::add(ResTable* src)
+{
+ mError = src->mError;
+ mParams = src->mParams;
+
+ for (size_t i=0; i<src->mHeaders.size(); i++) {
+ mHeaders.add(src->mHeaders[i]);
+ }
+
+ for (size_t i=0; i<src->mPackageGroups.size(); i++) {
+ PackageGroup* srcPg = src->mPackageGroups[i];
+ PackageGroup* pg = new PackageGroup(this, srcPg->name, srcPg->id);
+ for (size_t j=0; j<srcPg->packages.size(); j++) {
+ pg->packages.add(srcPg->packages[j]);
+ }
+ pg->basePackage = srcPg->basePackage;
+ pg->typeCount = srcPg->typeCount;
+ mPackageGroups.add(pg);
+ }
+
+ memcpy(mPackageMap, src->mPackageMap, sizeof(mPackageMap));
+
+ return mError;
+}
+
status_t ResTable::add(const void* data, size_t size, void* cookie,
Asset* asset, bool copyData)
{
if (!data) return NO_ERROR;
- Header* header = new Header;
+ Header* header = new Header(this);
header->index = mHeaders.size();
header->cookie = cookie;
mHeaders.add(header);
@@ -1682,10 +1717,12 @@ void ResTable::uninit()
N = mHeaders.size();
for (size_t i=0; i<N; i++) {
Header* header = mHeaders[i];
- if (header->ownedData) {
- free(header->ownedData);
+ if (header->owner == this) {
+ if (header->ownedData) {
+ free(header->ownedData);
+ }
+ delete header;
}
- delete header;
}
mPackageGroups.clear();
@@ -1728,8 +1765,8 @@ bool ResTable::getResourceName(uint32_t resID, resource_name* outName) const
outName->package = grp->name.string();
outName->packageLen = grp->name.size();
- outName->type = grp->typeStrings.stringAt(t, &outName->typeLen);
- outName->name = grp->keyStrings.stringAt(
+ outName->type = grp->basePackage->typeStrings.stringAt(t, &outName->typeLen);
+ outName->name = grp->basePackage->keyStrings.stringAt(
dtohl(entry->key.index), &outName->nameLen);
return true;
}
@@ -2331,13 +2368,13 @@ nope:
continue;
}
- const ssize_t ti = group->typeStrings.indexOfString(type, typeLen);
+ const ssize_t ti = group->basePackage->typeStrings.indexOfString(type, typeLen);
if (ti < 0) {
TABLE_NOISY(printf("Type not found in package %s\n", String8(group->name).string()));
continue;
}
- const ssize_t ei = group->keyStrings.indexOfString(name, nameLen);
+ const ssize_t ei = group->basePackage->keyStrings.indexOfString(name, nameLen);
if (ei < 0) {
TABLE_NOISY(printf("Name not found in package %s\n", String8(group->name).string()));
continue;
@@ -3630,25 +3667,36 @@ status_t ResTable::parsePackage(const ResTable_package* const pkg,
PackageGroup* group = NULL;
uint32_t id = dtohl(pkg->id);
if (id != 0 && id < 256) {
+
+ package = new Package(this, header, pkg);
+ if (package == NULL) {
+ return (mError=NO_MEMORY);
+ }
+
size_t idx = mPackageMap[id];
if (idx == 0) {
idx = mPackageGroups.size()+1;
char16_t tmpName[sizeof(pkg->name)/sizeof(char16_t)];
strcpy16_dtoh(tmpName, pkg->name, sizeof(pkg->name)/sizeof(char16_t));
- group = new PackageGroup(String16(tmpName), id);
+ group = new PackageGroup(this, String16(tmpName), id);
if (group == NULL) {
+ delete package;
return (mError=NO_MEMORY);
}
- err = group->typeStrings.setTo(base+dtohl(pkg->typeStrings),
+ err = package->typeStrings.setTo(base+dtohl(pkg->typeStrings),
header->dataEnd-(base+dtohl(pkg->typeStrings)));
if (err != NO_ERROR) {
+ delete group;
+ delete package;
return (mError=err);
}
- err = group->keyStrings.setTo(base+dtohl(pkg->keyStrings),
+ err = package->keyStrings.setTo(base+dtohl(pkg->keyStrings),
header->dataEnd-(base+dtohl(pkg->keyStrings)));
if (err != NO_ERROR) {
+ delete group;
+ delete package;
return (mError=err);
}
@@ -3657,6 +3705,8 @@ status_t ResTable::parsePackage(const ResTable_package* const pkg,
if (err < NO_ERROR) {
return (mError=err);
}
+ group->basePackage = package;
+
mPackageMap[id] = (uint8_t)idx;
} else {
group = mPackageGroups.itemAt(idx-1);
@@ -3664,10 +3714,6 @@ status_t ResTable::parsePackage(const ResTable_package* const pkg,
return (mError=UNKNOWN_ERROR);
}
}
- package = new Package(header, pkg);
- if (package == NULL) {
- return (mError=NO_MEMORY);
- }
err = group->packages.add(package);
if (err < NO_ERROR) {
return (mError=err);
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-12-09 08:34:15 +0000