/*
* Determine whether or not we want to try to compress this file based
* on the file extension.
*/
bool okayToCompress(Bundle* bundle, const String8& pathName)
{
String8 ext = pathName.getPathExtension();
int i;
if (ext.length() == 0)
return true;
for (i = 0; i < NELEM(kNoCompressExt); i++) {
if (strcasecmp(ext.string(), kNoCompressExt[i]) == 0)
return false;
}
const android::Vector<const char*>& others(bundle->getNoCompressExtensions());
for (i = 0; i < (int)others.size(); i++) {
const char* str = others[i];
int pos = pathName.length() - strlen(str);
if (pos < 0) {
continue;
}
const char* path = pathName.string();
if (strcasecmp(path + pos, str) == 0) {
return false;
}
}
return true;
}
/*
* Process a regular file, adding it to the archive if appropriate.
*
* This function is intended for use when creating a cached overlay package.
* Only xml and .9.png files are processed and added to the package.
*
* If we're in "update" mode, and the file already exists in the archive,
* delete the existing entry before adding the new one.
*/
bool processOverlayFile(Bundle* bundle, ZipFile* zip,
String8 storageName, const sp<const AaptFile>& file)
{
const bool hasData = file->hasData();
storageName.convertToResPath();
ZipEntry* entry;
bool fromGzip = false;
status_t result;
if (strcasecmp(storageName.getPathExtension().string(), ".gz") == 0) {
fromGzip = true;
storageName = storageName.getBasePath();
}
if (bundle->getUpdate()) {
entry = zip->getEntryByName(storageName.string());
if (entry != NULL) {
/* file already exists in archive; there can be only one */
if (entry->getMarked()) {
fprintf(stderr,
"ERROR: '%s' exists twice (check for with & w/o '.gz'?)\n",
file->getPrintableSource().string());
return false;
}
zip->remove(entry);
}
}
if (hasData) {
const char* name = storageName.string();
if (endsWith(name, ".9.png") || endsWith(name, ".xml") || endsWith(name, ".arsc")) {
result = zip->add(file->getData(), file->getSize(), storageName.string(),
file->getCompressionMethod(), &entry);
if (result == NO_ERROR) {
if (bundle->getVerbose()) {
printf(" '%s'%s", storageName.string(), fromGzip ? " (from .gz)" : "");
if (entry->getCompressionMethod() == ZipEntry::kCompressStored) {
printf(" (not compressed)\n");
} else {
printf(" (compressed %d%%)\n", calcPercent(entry->getUncompressedLen(),
entry->getCompressedLen()));
}
}
entry->setMarked(true);
} else {
if (result == ALREADY_EXISTS) {
fprintf(stderr, " Unable to add '%s': file already in archive (try '-u'?)\n",
file->getPrintableSource().string());
} else {
fprintf(stderr, " Unable to add '%s': Zip add failed\n",
file->getPrintableSource().string());
}
return false;
}
}
}
return true;
}
/*
* Search the plugins directory for a plugin that supports the scheme
* specified by uuid
*
* If found:
* mLibrary holds a strong pointer to the dlopen'd library
* mFactory is set to the library's factory method
* mInitCheck is set to OK
*
* If not found:
* mLibrary is cleared and mFactory are set to NULL
* mInitCheck is set to an error (!OK)
*/
void Crypto::findFactoryForScheme(const uint8_t uuid[16]) {
closeFactory();
// lock static maps
Mutex::Autolock autoLock(mMapLock);
// first check cache
Vector<uint8_t> uuidVector;
uuidVector.appendArray(uuid, sizeof(uuid));
ssize_t index = mUUIDToLibraryPathMap.indexOfKey(uuidVector);
if (index >= 0) {
if (loadLibraryForScheme(mUUIDToLibraryPathMap[index], uuid)) {
mInitCheck = OK;
return;
} else {
ALOGE("Failed to load from cached library path!");
mInitCheck = ERROR_UNSUPPORTED;
return;
}
}
// no luck, have to search
String8 dirPath("/vendor/lib/mediadrm");
String8 pluginPath;
DIR* pDir = opendir(dirPath.string());
if (pDir) {
struct dirent* pEntry;
while ((pEntry = readdir(pDir))) {
pluginPath = dirPath + "/" + pEntry->d_name;
if (pluginPath.getPathExtension() == ".so") {
if (loadLibraryForScheme(pluginPath, uuid)) {
mUUIDToLibraryPathMap.add(uuidVector, pluginPath);
mInitCheck = OK;
closedir(pDir);
return;
}
}
}
closedir(pDir);
}
// try the legacy libdrmdecrypt.so
pluginPath = "libdrmdecrypt.so";
if (loadLibraryForScheme(pluginPath, uuid)) {
mUUIDToLibraryPathMap.add(uuidVector, pluginPath);
mInitCheck = OK;
return;
}
mInitCheck = ERROR_UNSUPPORTED;
}
bool DrmManager::canHandle(int uniqueId, const String8& path, const String8& mimeType) {
Mutex::Autolock _l(mLock);
const String8 plugInId = getSupportedPlugInId(mimeType);
bool result = (EMPTY_STRING != plugInId) ? true : false;
if (0 < path.length()) {
if (result) {
IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId);
result = rDrmEngine.canHandle(uniqueId, path);
} else {
String8 extension = path.getPathExtension();
if (String8("") != extension) {
result = canHandle(uniqueId, path);
}
}
}
return result;
}
String8 DrmManager::getSupportedPlugInIdFromPath(int uniqueId, const String8& path) {
String8 plugInId("");
const String8 fileSuffix = path.getPathExtension();
for (unsigned int index = 0; index < mSupportInfoToPlugInIdMap.size(); index++) {
const DrmSupportInfo& drmSupportInfo = mSupportInfoToPlugInIdMap.keyAt(index);
if (drmSupportInfo.isSupportedFileSuffix(fileSuffix)) {
String8 key = mSupportInfoToPlugInIdMap.valueFor(drmSupportInfo);
IDrmEngine& drmEngine = mPlugInManager.getPlugIn(key);
if (drmEngine.canHandle(uniqueId, path)) {
plugInId = key;
break;
}
}
}
return plugInId;
}
/*
* Process a regular file, adding it to the archive if appropriate.
*
* If we're in "update" mode, and the file already exists in the archive,
* delete the existing entry before adding the new one.
*/
bool processFile(Bundle* bundle, ZipFile* zip,
String8 storageName, const sp<const AaptFile>& file)
{
const bool hasData = file->hasData();
ZipEntry* entry;
bool fromGzip = false;
status_t result;
/*
* See if the filename ends in ".EXCLUDE". We can't use
* String8::getPathExtension() because the length of what it considers
* to be an extension is capped.
*
* The Asset Manager doesn't check for ".EXCLUDE" in Zip archives,
* so there's no value in adding them (and it makes life easier on
* the AssetManager lib if we don't).
*
* NOTE: this restriction has been removed. If you're in this code, you
* should clean this up, but I'm in here getting rid of Path Name, and I
* don't want to make other potentially breaking changes --joeo
*/
int fileNameLen = storageName.length();
int excludeExtensionLen = strlen(kExcludeExtension);
if (fileNameLen > excludeExtensionLen
&& (0 == strcmp(storageName.string() + (fileNameLen - excludeExtensionLen),
kExcludeExtension))) {
fprintf(stderr, "warning: '%s' not added to Zip\n", storageName.string());
return true;
}
if (strcasecmp(storageName.getPathExtension().string(), ".gz") == 0) {
fromGzip = true;
storageName = storageName.getBasePath();
}
if (bundle->getUpdate()) {
entry = zip->getEntryByName(storageName.string());
if (entry != NULL) {
/* file already exists in archive; there can be only one */
if (entry->getMarked()) {
fprintf(stderr,
"ERROR: '%s' exists twice (check for with & w/o '.gz'?)\n",
file->getPrintableSource().string());
return false;
}
if (!hasData) {
const String8& srcName = file->getSourceFile();
time_t fileModWhen;
fileModWhen = getFileModDate(srcName.string());
if (fileModWhen == (time_t) -1) { // file existence tested earlier,
return false; // not expecting an error here
}
if (fileModWhen > entry->getModWhen()) {
// mark as deleted so add() will succeed
if (bundle->getVerbose()) {
printf(" (removing old '%s')\n", storageName.string());
}
zip->remove(entry);
} else {
// version in archive is newer
if (bundle->getVerbose()) {
printf(" (not updating '%s')\n", storageName.string());
}
entry->setMarked(true);
return true;
}
} else {
// Generated files are always replaced.
zip->remove(entry);
}
}
}
//android_setMinPriority(NULL, ANDROID_LOG_VERBOSE);
if (fromGzip) {
result = zip->addGzip(file->getSourceFile().string(), storageName.string(), &entry);
} else if (!hasData) {
/* don't compress certain files, e.g. PNGs */
int compressionMethod = bundle->getCompressionMethod();
if (!okayToCompress(bundle, storageName)) {
compressionMethod = ZipEntry::kCompressStored;
}
result = zip->add(file->getSourceFile().string(), storageName.string(), compressionMethod,
&entry);
} else {
result = zip->add(file->getData(), file->getSize(), storageName.string(),
file->getCompressionMethod(), &entry);
}
if (result == NO_ERROR) {
if (bundle->getVerbose()) {
printf(" '%s'%s", storageName.string(), fromGzip ? " (from .gz)" : "");
if (entry->getCompressionMethod() == ZipEntry::kCompressStored) {
printf(" (not compressed)\n");
} else {
printf(" (compressed %d%%)\n", calcPercent(entry->getUncompressedLen(),
entry->getCompressedLen()));
}
}
entry->setMarked(true);
} else {
if (result == ALREADY_EXISTS) {
fprintf(stderr, " Unable to add '%s': file already in archive (try '-u'?)\n",
file->getPrintableSource().string());
} else {
fprintf(stderr, " Unable to add '%s': Zip add failed (%d)\n",
file->getPrintableSource().string(), result);
}
return false;
}
return true;
}
bool FwdLockEngine::onCanHandle(int /* uniqueId */, const String8& path) {
bool result = false;
String8 extString = path.getPathExtension();
return IsFileSuffixSupported(extString);
}
bool DrmPassthruPlugIn::onCanHandle(int uniqueId, const String8& path) {
ALOGV("DrmPassthruPlugIn::canHandle: %s ", path.string());
String8 extension = path.getPathExtension();
extension.toLower();
return (String8(".passthru") == extension);
}
