libutils clean-up
Change-Id: I6ff4cfc736751de2912c697f954e45e275f2d386
This commit is contained in:
parent
b4f1a027cb
commit
002e1e58df
|
@ -9,7 +9,7 @@
|
||||||
#include <binder/Parcel.h>
|
#include <binder/Parcel.h>
|
||||||
#include <binder/ProcessState.h>
|
#include <binder/ProcessState.h>
|
||||||
#include <binder/IServiceManager.h>
|
#include <binder/IServiceManager.h>
|
||||||
#include <utils/TextOutput.h>
|
#include <binder/TextOutput.h>
|
||||||
#include <utils/Vector.h>
|
#include <utils/Vector.h>
|
||||||
|
|
||||||
#include <getopt.h>
|
#include <getopt.h>
|
||||||
|
|
|
@ -1,12 +1,23 @@
|
||||||
/*
|
/*
|
||||||
* Command line access to services.
|
* Copyright 2013 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 <binder/Parcel.h>
|
#include <binder/Parcel.h>
|
||||||
#include <binder/ProcessState.h>
|
#include <binder/ProcessState.h>
|
||||||
#include <binder/IServiceManager.h>
|
#include <binder/IServiceManager.h>
|
||||||
#include <utils/TextOutput.h>
|
#include <binder/TextOutput.h>
|
||||||
|
|
||||||
#include <getopt.h>
|
#include <getopt.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
|
|
|
@ -17,7 +17,7 @@
|
||||||
#ifndef ANDROID_BUFFEREDTEXTOUTPUT_H
|
#ifndef ANDROID_BUFFEREDTEXTOUTPUT_H
|
||||||
#define ANDROID_BUFFEREDTEXTOUTPUT_H
|
#define ANDROID_BUFFEREDTEXTOUTPUT_H
|
||||||
|
|
||||||
#include <utils/TextOutput.h>
|
#include <binder/TextOutput.h>
|
||||||
#include <utils/threads.h>
|
#include <utils/threads.h>
|
||||||
#include <cutils/uio.h>
|
#include <cutils/uio.h>
|
||||||
|
|
|
@ -0,0 +1,49 @@
|
||||||
|
/*
|
||||||
|
* Copyright (C) 2005 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 ANDROID_BINDER_DEBUG_H
|
||||||
|
#define ANDROID_BINDER_DEBUG_H
|
||||||
|
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
|
||||||
|
namespace android {
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
#endif
|
||||||
|
|
||||||
|
const char* stringForIndent(int32_t indentLevel);
|
||||||
|
|
||||||
|
typedef void (*debugPrintFunc)(void* cookie, const char* txt);
|
||||||
|
|
||||||
|
void printTypeCode(uint32_t typeCode,
|
||||||
|
debugPrintFunc func = 0, void* cookie = 0);
|
||||||
|
|
||||||
|
void printHexData(int32_t indent, const void *buf, size_t length,
|
||||||
|
size_t bytesPerLine=16, int32_t singleLineBytesCutoff=16,
|
||||||
|
size_t alignment=0, bool cArrayStyle=false,
|
||||||
|
debugPrintFunc func = 0, void* cookie = 0);
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// ---------------------------------------------------------------------------
|
||||||
|
}; // namespace android
|
||||||
|
|
||||||
|
#endif // ANDROID_BINDER_DEBUG_H
|
|
@ -27,6 +27,9 @@
|
||||||
|
|
||||||
namespace android {
|
namespace android {
|
||||||
|
|
||||||
|
// For TextStream.cpp
|
||||||
|
extern Vector<int32_t> gTextBuffers;
|
||||||
|
|
||||||
// For ProcessState.cpp
|
// For ProcessState.cpp
|
||||||
extern Mutex gProcessMutex;
|
extern Mutex gProcessMutex;
|
||||||
extern sp<ProcessState> gProcess;
|
extern sp<ProcessState> gProcess;
|
||||||
|
|
|
@ -1,35 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
// All static variables go here, to control initialization and
|
|
||||||
// destruction order in the library.
|
|
||||||
|
|
||||||
#include <utils/threads.h>
|
|
||||||
#include <utils/KeyedVector.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
// For TextStream.cpp
|
|
||||||
extern Vector<int32_t> gTextBuffers;
|
|
||||||
|
|
||||||
// For String8.cpp
|
|
||||||
extern void initialize_string8();
|
|
||||||
extern void terminate_string8();
|
|
||||||
|
|
||||||
// For String16.cpp
|
|
||||||
extern void initialize_string16();
|
|
||||||
extern void terminate_string16();
|
|
||||||
|
|
||||||
} // namespace android
|
|
|
@ -14,8 +14,8 @@
|
||||||
* limitations under the License.
|
* limitations under the License.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#ifndef ANDROID_DEBUG_H
|
#ifndef ANDROID_UTILS_DEBUG_H
|
||||||
#define ANDROID_DEBUG_H
|
#define ANDROID_UTILS_DEBUG_H
|
||||||
|
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <sys/types.h>
|
#include <sys/types.h>
|
||||||
|
@ -42,29 +42,7 @@ template<typename LHS, typename RHS>
|
||||||
struct CompileTimeIfElse<false, LHS, RHS> { typedef RHS TYPE; };
|
struct CompileTimeIfElse<false, LHS, RHS> { typedef RHS TYPE; };
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
const char* stringForIndent(int32_t indentLevel);
|
|
||||||
|
|
||||||
typedef void (*debugPrintFunc)(void* cookie, const char* txt);
|
|
||||||
|
|
||||||
void printTypeCode(uint32_t typeCode,
|
|
||||||
debugPrintFunc func = 0, void* cookie = 0);
|
|
||||||
|
|
||||||
void printHexData(int32_t indent, const void *buf, size_t length,
|
|
||||||
size_t bytesPerLine=16, int32_t singleLineBytesCutoff=16,
|
|
||||||
size_t alignment=0, bool cArrayStyle=false,
|
|
||||||
debugPrintFunc func = 0, void* cookie = 0);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
}; // namespace android
|
}; // namespace android
|
||||||
|
|
||||||
#endif // ANDROID_DEBUG_H
|
#endif // ANDROID_UTILS_DEBUG_H
|
||||||
|
|
|
@ -1,247 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 2010 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 ANDROID_UTILS_GENERATION_CACHE_H
|
|
||||||
#define ANDROID_UTILS_GENERATION_CACHE_H
|
|
||||||
|
|
||||||
#include <utils/KeyedVector.h>
|
|
||||||
#include <utils/RefBase.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
|
|
||||||
/**
|
|
||||||
* GenerationCache callback used when an item is removed
|
|
||||||
*/
|
|
||||||
template<typename EntryKey, typename EntryValue>
|
|
||||||
class OnEntryRemoved {
|
|
||||||
public:
|
|
||||||
virtual ~OnEntryRemoved() { };
|
|
||||||
virtual void operator()(EntryKey& key, EntryValue& value) = 0;
|
|
||||||
}; // class OnEntryRemoved
|
|
||||||
|
|
||||||
template<typename EntryKey, typename EntryValue>
|
|
||||||
struct Entry: public LightRefBase<Entry<EntryKey, EntryValue> > {
|
|
||||||
Entry(const Entry<EntryKey, EntryValue>& e) :
|
|
||||||
key(e.key), value(e.value),
|
|
||||||
parent(e.parent), child(e.child) { }
|
|
||||||
Entry(const EntryKey& key, const EntryValue& value) :
|
|
||||||
key(key), value(value) { }
|
|
||||||
|
|
||||||
EntryKey key;
|
|
||||||
EntryValue value;
|
|
||||||
|
|
||||||
sp<Entry<EntryKey, EntryValue> > parent; // next older entry
|
|
||||||
sp<Entry<EntryKey, EntryValue> > child; // next younger entry
|
|
||||||
}; // struct Entry
|
|
||||||
|
|
||||||
/**
|
|
||||||
* A LRU type cache
|
|
||||||
*/
|
|
||||||
template<typename K, typename V>
|
|
||||||
class GenerationCache {
|
|
||||||
public:
|
|
||||||
GenerationCache(uint32_t maxCapacity);
|
|
||||||
virtual ~GenerationCache();
|
|
||||||
|
|
||||||
enum Capacity {
|
|
||||||
kUnlimitedCapacity,
|
|
||||||
};
|
|
||||||
|
|
||||||
void setOnEntryRemovedListener(OnEntryRemoved<K, V>* listener);
|
|
||||||
|
|
||||||
size_t size() const;
|
|
||||||
|
|
||||||
void clear();
|
|
||||||
|
|
||||||
bool contains(const K& key) const;
|
|
||||||
const K& getKeyAt(size_t index) const;
|
|
||||||
const V& getValueAt(size_t index) const;
|
|
||||||
|
|
||||||
const V& get(const K& key);
|
|
||||||
bool put(const K& key, const V& value);
|
|
||||||
|
|
||||||
void removeAt(ssize_t index);
|
|
||||||
bool remove(const K& key);
|
|
||||||
bool removeOldest();
|
|
||||||
|
|
||||||
private:
|
|
||||||
KeyedVector<K, sp<Entry<K, V> > > mCache;
|
|
||||||
uint32_t mMaxCapacity;
|
|
||||||
|
|
||||||
OnEntryRemoved<K, V>* mListener;
|
|
||||||
|
|
||||||
sp<Entry<K, V> > mOldest;
|
|
||||||
sp<Entry<K, V> > mYoungest;
|
|
||||||
|
|
||||||
void attachToCache(const sp<Entry<K, V> >& entry);
|
|
||||||
void detachFromCache(const sp<Entry<K, V> >& entry);
|
|
||||||
|
|
||||||
const V mNullValue;
|
|
||||||
}; // class GenerationCache
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
GenerationCache<K, V>::GenerationCache(uint32_t maxCapacity): mMaxCapacity(maxCapacity),
|
|
||||||
mListener(NULL), mNullValue(NULL) {
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
GenerationCache<K, V>::~GenerationCache() {
|
|
||||||
clear();
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
uint32_t GenerationCache<K, V>::size() const {
|
|
||||||
return mCache.size();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Should be set by the user of the Cache so that the callback is called whenever an item is
|
|
||||||
* removed from the cache
|
|
||||||
*/
|
|
||||||
template<typename K, typename V>
|
|
||||||
void GenerationCache<K, V>::setOnEntryRemovedListener(OnEntryRemoved<K, V>* listener) {
|
|
||||||
mListener = listener;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
void GenerationCache<K, V>::clear() {
|
|
||||||
if (mListener) {
|
|
||||||
for (uint32_t i = 0; i < mCache.size(); i++) {
|
|
||||||
sp<Entry<K, V> > entry = mCache.valueAt(i);
|
|
||||||
if (mListener) {
|
|
||||||
(*mListener)(entry->key, entry->value);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
mCache.clear();
|
|
||||||
mYoungest.clear();
|
|
||||||
mOldest.clear();
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
bool GenerationCache<K, V>::contains(const K& key) const {
|
|
||||||
return mCache.indexOfKey(key) >= 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
const K& GenerationCache<K, V>::getKeyAt(size_t index) const {
|
|
||||||
return mCache.keyAt(index);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
const V& GenerationCache<K, V>::getValueAt(size_t index) const {
|
|
||||||
return mCache.valueAt(index)->value;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
const V& GenerationCache<K, V>::get(const K& key) {
|
|
||||||
ssize_t index = mCache.indexOfKey(key);
|
|
||||||
if (index >= 0) {
|
|
||||||
const sp<Entry<K, V> >& entry = mCache.valueAt(index);
|
|
||||||
detachFromCache(entry);
|
|
||||||
attachToCache(entry);
|
|
||||||
return entry->value;
|
|
||||||
}
|
|
||||||
|
|
||||||
return mNullValue;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
bool GenerationCache<K, V>::put(const K& key, const V& value) {
|
|
||||||
if (mMaxCapacity != kUnlimitedCapacity && mCache.size() >= mMaxCapacity) {
|
|
||||||
removeOldest();
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t index = mCache.indexOfKey(key);
|
|
||||||
if (index < 0) {
|
|
||||||
sp<Entry<K, V> > entry = new Entry<K, V>(key, value);
|
|
||||||
mCache.add(key, entry);
|
|
||||||
attachToCache(entry);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
bool GenerationCache<K, V>::remove(const K& key) {
|
|
||||||
ssize_t index = mCache.indexOfKey(key);
|
|
||||||
if (index >= 0) {
|
|
||||||
removeAt(index);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
void GenerationCache<K, V>::removeAt(ssize_t index) {
|
|
||||||
sp<Entry<K, V> > entry = mCache.valueAt(index);
|
|
||||||
if (mListener) {
|
|
||||||
(*mListener)(entry->key, entry->value);
|
|
||||||
}
|
|
||||||
mCache.removeItemsAt(index, 1);
|
|
||||||
detachFromCache(entry);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
bool GenerationCache<K, V>::removeOldest() {
|
|
||||||
if (mOldest.get()) {
|
|
||||||
ssize_t index = mCache.indexOfKey(mOldest->key);
|
|
||||||
if (index >= 0) {
|
|
||||||
removeAt(index);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
ALOGE("GenerationCache: removeOldest failed to find the item in the cache "
|
|
||||||
"with the given key, but we know it must be in there. "
|
|
||||||
"Is the key comparator kaput?");
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
void GenerationCache<K, V>::attachToCache(const sp<Entry<K, V> >& entry) {
|
|
||||||
if (!mYoungest.get()) {
|
|
||||||
mYoungest = mOldest = entry;
|
|
||||||
} else {
|
|
||||||
entry->parent = mYoungest;
|
|
||||||
mYoungest->child = entry;
|
|
||||||
mYoungest = entry;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename K, typename V>
|
|
||||||
void GenerationCache<K, V>::detachFromCache(const sp<Entry<K, V> >& entry) {
|
|
||||||
if (entry->parent.get()) {
|
|
||||||
entry->parent->child = entry->child;
|
|
||||||
} else {
|
|
||||||
mOldest = entry->child;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (entry->child.get()) {
|
|
||||||
entry->child->parent = entry->parent;
|
|
||||||
} else {
|
|
||||||
mYoungest = entry->parent;
|
|
||||||
}
|
|
||||||
|
|
||||||
entry->parent.clear();
|
|
||||||
entry->child.clear();
|
|
||||||
}
|
|
||||||
|
|
||||||
}; // namespace android
|
|
||||||
|
|
||||||
#endif // ANDROID_UTILS_GENERATION_CACHE_H
|
|
|
@ -18,12 +18,19 @@
|
||||||
#define ANDROID_UTILS_LRU_CACHE_H
|
#define ANDROID_UTILS_LRU_CACHE_H
|
||||||
|
|
||||||
#include <utils/BasicHashtable.h>
|
#include <utils/BasicHashtable.h>
|
||||||
#include <utils/GenerationCache.h>
|
|
||||||
#include <utils/UniquePtr.h>
|
#include <utils/UniquePtr.h>
|
||||||
|
|
||||||
namespace android {
|
namespace android {
|
||||||
|
|
||||||
// OnEntryRemoved is defined in GenerationCache.h, but maybe should move here.
|
/**
|
||||||
|
* GenerationCache callback used when an item is removed
|
||||||
|
*/
|
||||||
|
template<typename EntryKey, typename EntryValue>
|
||||||
|
class OnEntryRemoved {
|
||||||
|
public:
|
||||||
|
virtual ~OnEntryRemoved() { };
|
||||||
|
virtual void operator()(EntryKey& key, EntryValue& value) = 0;
|
||||||
|
}; // class OnEntryRemoved
|
||||||
|
|
||||||
template <typename TKey, typename TValue>
|
template <typename TKey, typename TValue>
|
||||||
class LruCache {
|
class LruCache {
|
||||||
|
|
|
@ -117,8 +117,6 @@ private:
|
||||||
// require any change to the underlying SharedBuffer contents or reference count.
|
// require any change to the underlying SharedBuffer contents or reference count.
|
||||||
ANDROID_TRIVIAL_MOVE_TRAIT(String16)
|
ANDROID_TRIVIAL_MOVE_TRAIT(String16)
|
||||||
|
|
||||||
TextOutput& operator<<(TextOutput& to, const String16& val);
|
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// No user servicable parts below.
|
// No user servicable parts below.
|
||||||
|
|
||||||
|
|
|
@ -224,8 +224,6 @@ private:
|
||||||
// require any change to the underlying SharedBuffer contents or reference count.
|
// require any change to the underlying SharedBuffer contents or reference count.
|
||||||
ANDROID_TRIVIAL_MOVE_TRAIT(String8)
|
ANDROID_TRIVIAL_MOVE_TRAIT(String8)
|
||||||
|
|
||||||
TextOutput& operator<<(TextOutput& to, const String16& val);
|
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// No user servicable parts below.
|
// No user servicable parts below.
|
||||||
|
|
||||||
|
|
|
@ -1,83 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//
|
|
||||||
// Sortable array of strings. STL-ish, but STL-free.
|
|
||||||
//
|
|
||||||
#ifndef _LIBS_UTILS_STRING_ARRAY_H
|
|
||||||
#define _LIBS_UTILS_STRING_ARRAY_H
|
|
||||||
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
|
|
||||||
//
|
|
||||||
// An expanding array of strings. Add, get, sort, delete.
|
|
||||||
//
|
|
||||||
class StringArray {
|
|
||||||
public:
|
|
||||||
StringArray();
|
|
||||||
virtual ~StringArray();
|
|
||||||
|
|
||||||
//
|
|
||||||
// Add a string. A copy of the string is made.
|
|
||||||
//
|
|
||||||
bool push_back(const char* str);
|
|
||||||
|
|
||||||
//
|
|
||||||
// Delete an entry.
|
|
||||||
//
|
|
||||||
void erase(int idx);
|
|
||||||
|
|
||||||
//
|
|
||||||
// Sort the array.
|
|
||||||
//
|
|
||||||
void sort(int (*compare)(const void*, const void*));
|
|
||||||
|
|
||||||
//
|
|
||||||
// Pass this to the sort routine to do an ascending alphabetical sort.
|
|
||||||
//
|
|
||||||
static int cmpAscendingAlpha(const void* pstr1, const void* pstr2);
|
|
||||||
|
|
||||||
//
|
|
||||||
// Get the #of items in the array.
|
|
||||||
//
|
|
||||||
inline int size(void) const { return mCurrent; }
|
|
||||||
|
|
||||||
//
|
|
||||||
// Return entry N.
|
|
||||||
// [should use operator[] here]
|
|
||||||
//
|
|
||||||
const char* getEntry(int idx) const {
|
|
||||||
return (unsigned(idx) >= unsigned(mCurrent)) ? NULL : mArray[idx];
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// Set entry N to specified string.
|
|
||||||
// [should use operator[] here]
|
|
||||||
//
|
|
||||||
void setEntry(int idx, const char* str);
|
|
||||||
|
|
||||||
private:
|
|
||||||
int mMax;
|
|
||||||
int mCurrent;
|
|
||||||
char** mArray;
|
|
||||||
};
|
|
||||||
|
|
||||||
}; // namespace android
|
|
||||||
|
|
||||||
#endif // _LIBS_UTILS_STRING_ARRAY_H
|
|
|
@ -207,12 +207,6 @@ void sp<T>::set_pointer(T* ptr) {
|
||||||
m_ptr = ptr;
|
m_ptr = ptr;
|
||||||
}
|
}
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
inline TextOutput& operator<<(TextOutput& to, const sp<T>& val)
|
|
||||||
{
|
|
||||||
return printStrongPointer(to, val.get());
|
|
||||||
}
|
|
||||||
|
|
||||||
}; // namespace android
|
}; // namespace android
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
|
|
|
@ -22,7 +22,6 @@
|
||||||
|
|
||||||
namespace android {
|
namespace android {
|
||||||
|
|
||||||
int setCurrentTimeMillis(int64_t millis);
|
|
||||||
int64_t uptimeMillis();
|
int64_t uptimeMillis();
|
||||||
int64_t elapsedRealtime();
|
int64_t elapsedRealtime();
|
||||||
int64_t elapsedRealtimeNano();
|
int64_t elapsedRealtimeNano();
|
||||||
|
|
|
@ -103,43 +103,4 @@ int toMillisecondTimeoutDelay(nsecs_t referenceTime, nsecs_t timeoutTime);
|
||||||
} // extern "C"
|
} // extern "C"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// ------------------------------------------------------------------
|
|
||||||
// C++ API
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
/*
|
|
||||||
* Time the duration of something.
|
|
||||||
*
|
|
||||||
* Includes some timeval manipulation functions.
|
|
||||||
*/
|
|
||||||
class DurationTimer {
|
|
||||||
public:
|
|
||||||
DurationTimer() {}
|
|
||||||
~DurationTimer() {}
|
|
||||||
|
|
||||||
// Start the timer.
|
|
||||||
void start();
|
|
||||||
// Stop the timer.
|
|
||||||
void stop();
|
|
||||||
// Get the duration in microseconds.
|
|
||||||
long long durationUsecs() const;
|
|
||||||
|
|
||||||
// Subtract two timevals. Returns the difference (ptv1-ptv2) in
|
|
||||||
// microseconds.
|
|
||||||
static long long subtractTimevals(const struct timeval* ptv1,
|
|
||||||
const struct timeval* ptv2);
|
|
||||||
|
|
||||||
// Add the specified amount of time to the timeval.
|
|
||||||
static void addToTimeval(struct timeval* ptv, long usec);
|
|
||||||
|
|
||||||
private:
|
|
||||||
struct timeval mStartWhen;
|
|
||||||
struct timeval mStopWhen;
|
|
||||||
};
|
|
||||||
|
|
||||||
}; // android
|
|
||||||
#endif // def __cplusplus
|
|
||||||
|
|
||||||
#endif // _LIBS_UTILS_TIMERS_H
|
#endif // _LIBS_UTILS_TIMERS_H
|
||||||
|
|
|
@ -1,119 +0,0 @@
|
||||||
/*]
|
|
||||||
* Copyright (C) 2012 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 _LIBS_UTILS_WORK_QUEUE_H
|
|
||||||
#define _LIBS_UTILS_WORK_QUEUE_H
|
|
||||||
|
|
||||||
#include <utils/Errors.h>
|
|
||||||
#include <utils/Vector.h>
|
|
||||||
#include <utils/threads.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A threaded work queue.
|
|
||||||
*
|
|
||||||
* This class is designed to make it easy to run a bunch of isolated work
|
|
||||||
* units in parallel, using up to the specified number of threads.
|
|
||||||
* To use it, write a loop to post work units to the work queue, then synchronize
|
|
||||||
* on the queue at the end.
|
|
||||||
*/
|
|
||||||
class WorkQueue {
|
|
||||||
public:
|
|
||||||
class WorkUnit {
|
|
||||||
public:
|
|
||||||
WorkUnit() { }
|
|
||||||
virtual ~WorkUnit() { }
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Runs the work unit.
|
|
||||||
* If the result is 'true' then the work queue continues scheduling work as usual.
|
|
||||||
* If the result is 'false' then the work queue is canceled.
|
|
||||||
*/
|
|
||||||
virtual bool run() = 0;
|
|
||||||
};
|
|
||||||
|
|
||||||
/* Creates a work queue with the specified maximum number of work threads. */
|
|
||||||
WorkQueue(size_t maxThreads, bool canCallJava = true);
|
|
||||||
|
|
||||||
/* Destroys the work queue.
|
|
||||||
* Cancels pending work and waits for all remaining threads to complete.
|
|
||||||
*/
|
|
||||||
~WorkQueue();
|
|
||||||
|
|
||||||
/* Posts a work unit to run later.
|
|
||||||
* If the work queue has been canceled or is already finished, returns INVALID_OPERATION
|
|
||||||
* and does not take ownership of the work unit (caller must destroy it itself).
|
|
||||||
* Otherwise, returns OK and takes ownership of the work unit (the work queue will
|
|
||||||
* destroy it automatically).
|
|
||||||
*
|
|
||||||
* For flow control, this method blocks when the size of the pending work queue is more
|
|
||||||
* 'backlog' times the number of threads. This condition reduces the rate of entry into
|
|
||||||
* the pending work queue and prevents it from growing much more rapidly than the
|
|
||||||
* work threads can actually handle.
|
|
||||||
*
|
|
||||||
* If 'backlog' is 0, then no throttle is applied.
|
|
||||||
*/
|
|
||||||
status_t schedule(WorkUnit* workUnit, size_t backlog = 2);
|
|
||||||
|
|
||||||
/* Cancels all pending work.
|
|
||||||
* If the work queue is already finished, returns INVALID_OPERATION.
|
|
||||||
* If the work queue is already canceled, returns OK and does nothing else.
|
|
||||||
* Otherwise, returns OK, discards all pending work units and prevents additional
|
|
||||||
* work units from being scheduled.
|
|
||||||
*
|
|
||||||
* Call finish() after cancel() to wait for all remaining work to complete.
|
|
||||||
*/
|
|
||||||
status_t cancel();
|
|
||||||
|
|
||||||
/* Waits for all work to complete.
|
|
||||||
* If the work queue is already finished, returns INVALID_OPERATION.
|
|
||||||
* Otherwise, waits for all work to complete and returns OK.
|
|
||||||
*/
|
|
||||||
status_t finish();
|
|
||||||
|
|
||||||
private:
|
|
||||||
class WorkThread : public Thread {
|
|
||||||
public:
|
|
||||||
WorkThread(WorkQueue* workQueue, bool canCallJava);
|
|
||||||
virtual ~WorkThread();
|
|
||||||
|
|
||||||
private:
|
|
||||||
virtual bool threadLoop();
|
|
||||||
|
|
||||||
WorkQueue* const mWorkQueue;
|
|
||||||
};
|
|
||||||
|
|
||||||
status_t cancelLocked();
|
|
||||||
bool threadLoop(); // called from each work thread
|
|
||||||
|
|
||||||
const size_t mMaxThreads;
|
|
||||||
const bool mCanCallJava;
|
|
||||||
|
|
||||||
Mutex mLock;
|
|
||||||
Condition mWorkChangedCondition;
|
|
||||||
Condition mWorkDequeuedCondition;
|
|
||||||
|
|
||||||
bool mCanceled;
|
|
||||||
bool mFinished;
|
|
||||||
size_t mIdleThreads;
|
|
||||||
Vector<sp<WorkThread> > mWorkThreads;
|
|
||||||
Vector<WorkUnit*> mWorkUnits;
|
|
||||||
};
|
|
||||||
|
|
||||||
}; // namespace android
|
|
||||||
|
|
||||||
#endif // _LIBS_UTILS_WORK_QUEUE_H
|
|
|
@ -1,61 +0,0 @@
|
||||||
/*
|
|
||||||
* 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//
|
|
||||||
// C API for ead-only access to Zip archives, with minimal heap allocation.
|
|
||||||
//
|
|
||||||
#ifndef __LIBS_ZIPFILECRO_H
|
|
||||||
#define __LIBS_ZIPFILECRO_H
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <unistd.h>
|
|
||||||
|
|
||||||
#include <utils/Compat.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Trivial typedef to ensure that ZipFileCRO is not treated as a simple integer.
|
|
||||||
*/
|
|
||||||
typedef void* ZipFileCRO;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Trivial typedef to ensure that ZipEntryCRO is not treated as a simple
|
|
||||||
* integer. We use NULL to indicate an invalid value.
|
|
||||||
*/
|
|
||||||
typedef void* ZipEntryCRO;
|
|
||||||
|
|
||||||
extern ZipFileCRO ZipFileXRO_open(const char* path);
|
|
||||||
|
|
||||||
extern void ZipFileCRO_destroy(ZipFileCRO zip);
|
|
||||||
|
|
||||||
extern ZipEntryCRO ZipFileCRO_findEntryByName(ZipFileCRO zip,
|
|
||||||
const char* fileName);
|
|
||||||
|
|
||||||
extern bool ZipFileCRO_getEntryInfo(ZipFileCRO zip, ZipEntryCRO entry,
|
|
||||||
int* pMethod, size_t* pUncompLen,
|
|
||||||
size_t* pCompLen, off64_t* pOffset, long* pModWhen, long* pCrc32);
|
|
||||||
|
|
||||||
extern bool ZipFileCRO_uncompressEntry(ZipFileCRO zip, ZipEntryCRO entry, int fd);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /*__LIBS_ZIPFILECRO_H*/
|
|
|
@ -1,262 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 2007 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Read-only access to Zip archives, with minimal heap allocation.
|
|
||||||
*
|
|
||||||
* This is similar to the more-complete ZipFile class, but no attempt
|
|
||||||
* has been made to make them interchangeable. This class operates under
|
|
||||||
* a very different set of assumptions and constraints.
|
|
||||||
*
|
|
||||||
* One such assumption is that if you're getting file descriptors for
|
|
||||||
* use with this class as a child of a fork() operation, you must be on
|
|
||||||
* a pread() to guarantee correct operation. This is because pread() can
|
|
||||||
* atomically read at a file offset without worrying about a lock around an
|
|
||||||
* lseek() + read() pair.
|
|
||||||
*/
|
|
||||||
#ifndef __LIBS_ZIPFILERO_H
|
|
||||||
#define __LIBS_ZIPFILERO_H
|
|
||||||
|
|
||||||
#include <utils/Compat.h>
|
|
||||||
#include <utils/Errors.h>
|
|
||||||
#include <utils/FileMap.h>
|
|
||||||
#include <utils/threads.h>
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <unistd.h>
|
|
||||||
#include <time.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Trivial typedef to ensure that ZipEntryRO is not treated as a simple
|
|
||||||
* integer. We use NULL to indicate an invalid value.
|
|
||||||
*/
|
|
||||||
typedef void* ZipEntryRO;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Open a Zip archive for reading.
|
|
||||||
*
|
|
||||||
* We want "open" and "find entry by name" to be fast operations, and we
|
|
||||||
* want to use as little memory as possible. We memory-map the file,
|
|
||||||
* and load a hash table with pointers to the filenames (which aren't
|
|
||||||
* null-terminated). The other fields are at a fixed offset from the
|
|
||||||
* filename, so we don't need to extract those (but we do need to byte-read
|
|
||||||
* and endian-swap them every time we want them).
|
|
||||||
*
|
|
||||||
* To speed comparisons when doing a lookup by name, we could make the mapping
|
|
||||||
* "private" (copy-on-write) and null-terminate the filenames after verifying
|
|
||||||
* the record structure. However, this requires a private mapping of
|
|
||||||
* every page that the Central Directory touches. Easier to tuck a copy
|
|
||||||
* of the string length into the hash table entry.
|
|
||||||
*
|
|
||||||
* NOTE: If this is used on file descriptors inherited from a fork() operation,
|
|
||||||
* you must be on a platform that implements pread() to guarantee correctness
|
|
||||||
* on the shared file descriptors.
|
|
||||||
*/
|
|
||||||
class ZipFileRO {
|
|
||||||
public:
|
|
||||||
ZipFileRO()
|
|
||||||
: mFd(-1), mFileName(NULL), mFileLength(-1),
|
|
||||||
mDirectoryMap(NULL),
|
|
||||||
mNumEntries(-1), mDirectoryOffset(-1),
|
|
||||||
mHashTableSize(-1), mHashTable(NULL)
|
|
||||||
{}
|
|
||||||
|
|
||||||
~ZipFileRO();
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Open an archive.
|
|
||||||
*/
|
|
||||||
status_t open(const char* zipFileName);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Find an entry, by name. Returns the entry identifier, or NULL if
|
|
||||||
* not found.
|
|
||||||
*
|
|
||||||
* If two entries have the same name, one will be chosen at semi-random.
|
|
||||||
*/
|
|
||||||
ZipEntryRO findEntryByName(const char* fileName) const;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Return the #of entries in the Zip archive.
|
|
||||||
*/
|
|
||||||
int getNumEntries(void) const {
|
|
||||||
return mNumEntries;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Return the Nth entry. Zip file entries are not stored in sorted
|
|
||||||
* order, and updated entries may appear at the end, so anyone walking
|
|
||||||
* the archive needs to avoid making ordering assumptions. We take
|
|
||||||
* that further by returning the Nth non-empty entry in the hash table
|
|
||||||
* rather than the Nth entry in the archive.
|
|
||||||
*
|
|
||||||
* Valid values are [0..numEntries).
|
|
||||||
*
|
|
||||||
* [This is currently O(n). If it needs to be fast we can allocate an
|
|
||||||
* additional data structure or provide an iterator interface.]
|
|
||||||
*/
|
|
||||||
ZipEntryRO findEntryByIndex(int idx) const;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Copy the filename into the supplied buffer. Returns 0 on success,
|
|
||||||
* -1 if "entry" is invalid, or the filename length if it didn't fit. The
|
|
||||||
* length, and the returned string, include the null-termination.
|
|
||||||
*/
|
|
||||||
int getEntryFileName(ZipEntryRO entry, char* buffer, int bufLen) const;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the vital stats for an entry. Pass in NULL pointers for anything
|
|
||||||
* you don't need.
|
|
||||||
*
|
|
||||||
* "*pOffset" holds the Zip file offset of the entry's data.
|
|
||||||
*
|
|
||||||
* Returns "false" if "entry" is bogus or if the data in the Zip file
|
|
||||||
* appears to be bad.
|
|
||||||
*/
|
|
||||||
bool getEntryInfo(ZipEntryRO entry, int* pMethod, size_t* pUncompLen,
|
|
||||||
size_t* pCompLen, off64_t* pOffset, long* pModWhen, long* pCrc32) const;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Create a new FileMap object that maps a subset of the archive. For
|
|
||||||
* an uncompressed entry this effectively provides a pointer to the
|
|
||||||
* actual data, for a compressed entry this provides the input buffer
|
|
||||||
* for inflate().
|
|
||||||
*/
|
|
||||||
FileMap* createEntryFileMap(ZipEntryRO entry) const;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Uncompress the data into a buffer. Depending on the compression
|
|
||||||
* format, this is either an "inflate" operation or a memcpy.
|
|
||||||
*
|
|
||||||
* Use "uncompLen" from getEntryInfo() to determine the required
|
|
||||||
* buffer size.
|
|
||||||
*
|
|
||||||
* Returns "true" on success.
|
|
||||||
*/
|
|
||||||
bool uncompressEntry(ZipEntryRO entry, void* buffer) const;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Uncompress the data to an open file descriptor.
|
|
||||||
*/
|
|
||||||
bool uncompressEntry(ZipEntryRO entry, int fd) const;
|
|
||||||
|
|
||||||
/* Zip compression methods we support */
|
|
||||||
enum {
|
|
||||||
kCompressStored = 0, // no compression
|
|
||||||
kCompressDeflated = 8, // standard deflate
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Utility function: uncompress deflated data, buffer to buffer.
|
|
||||||
*/
|
|
||||||
static bool inflateBuffer(void* outBuf, const void* inBuf,
|
|
||||||
size_t uncompLen, size_t compLen);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Utility function: uncompress deflated data, buffer to fd.
|
|
||||||
*/
|
|
||||||
static bool inflateBuffer(int fd, const void* inBuf,
|
|
||||||
size_t uncompLen, size_t compLen);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Utility function to convert ZIP's time format to a timespec struct.
|
|
||||||
*/
|
|
||||||
static inline void zipTimeToTimespec(long when, struct tm* timespec) {
|
|
||||||
const long date = when >> 16;
|
|
||||||
timespec->tm_year = ((date >> 9) & 0x7F) + 80; // Zip is years since 1980
|
|
||||||
timespec->tm_mon = (date >> 5) & 0x0F;
|
|
||||||
timespec->tm_mday = date & 0x1F;
|
|
||||||
|
|
||||||
timespec->tm_hour = (when >> 11) & 0x1F;
|
|
||||||
timespec->tm_min = (when >> 5) & 0x3F;
|
|
||||||
timespec->tm_sec = (when & 0x1F) << 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Some basic functions for raw data manipulation. "LE" means
|
|
||||||
* Little Endian.
|
|
||||||
*/
|
|
||||||
static inline unsigned short get2LE(const unsigned char* buf) {
|
|
||||||
return buf[0] | (buf[1] << 8);
|
|
||||||
}
|
|
||||||
static inline unsigned long get4LE(const unsigned char* buf) {
|
|
||||||
return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
/* these are private and not defined */
|
|
||||||
ZipFileRO(const ZipFileRO& src);
|
|
||||||
ZipFileRO& operator=(const ZipFileRO& src);
|
|
||||||
|
|
||||||
/* locate and parse the central directory */
|
|
||||||
bool mapCentralDirectory(void);
|
|
||||||
|
|
||||||
/* parse the archive, prepping internal structures */
|
|
||||||
bool parseZipArchive(void);
|
|
||||||
|
|
||||||
/* add a new entry to the hash table */
|
|
||||||
void addToHash(const char* str, int strLen, unsigned int hash);
|
|
||||||
|
|
||||||
/* compute string hash code */
|
|
||||||
static unsigned int computeHash(const char* str, int len);
|
|
||||||
|
|
||||||
/* convert a ZipEntryRO back to a hash table index */
|
|
||||||
int entryToIndex(const ZipEntryRO entry) const;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* One entry in the hash table.
|
|
||||||
*/
|
|
||||||
typedef struct HashEntry {
|
|
||||||
const char* name;
|
|
||||||
unsigned short nameLen;
|
|
||||||
//unsigned int hash;
|
|
||||||
} HashEntry;
|
|
||||||
|
|
||||||
/* open Zip archive */
|
|
||||||
int mFd;
|
|
||||||
|
|
||||||
/* Lock for handling the file descriptor (seeks, etc) */
|
|
||||||
mutable Mutex mFdLock;
|
|
||||||
|
|
||||||
/* zip file name */
|
|
||||||
char* mFileName;
|
|
||||||
|
|
||||||
/* length of file */
|
|
||||||
size_t mFileLength;
|
|
||||||
|
|
||||||
/* mapped file */
|
|
||||||
FileMap* mDirectoryMap;
|
|
||||||
|
|
||||||
/* number of entries in the Zip archive */
|
|
||||||
int mNumEntries;
|
|
||||||
|
|
||||||
/* CD directory offset in the Zip archive */
|
|
||||||
off64_t mDirectoryOffset;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* We know how many entries are in the Zip archive, so we have a
|
|
||||||
* fixed-size hash table. We probe for an empty slot.
|
|
||||||
*/
|
|
||||||
int mHashTableSize;
|
|
||||||
HashEntry* mHashTable;
|
|
||||||
};
|
|
||||||
|
|
||||||
}; // namespace android
|
|
||||||
|
|
||||||
#endif /*__LIBS_ZIPFILERO_H*/
|
|
|
@ -1,67 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 2007 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//
|
|
||||||
// Miscellaneous zip/gzip utility functions.
|
|
||||||
//
|
|
||||||
#ifndef __LIBS_ZIPUTILS_H
|
|
||||||
#define __LIBS_ZIPUTILS_H
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Container class for utility functions, primarily for namespace reasons.
|
|
||||||
*/
|
|
||||||
class ZipUtils {
|
|
||||||
public:
|
|
||||||
/*
|
|
||||||
* General utility function for uncompressing "deflate" data from a file
|
|
||||||
* to a buffer.
|
|
||||||
*/
|
|
||||||
static bool inflateToBuffer(int fd, void* buf, long uncompressedLen,
|
|
||||||
long compressedLen);
|
|
||||||
static bool inflateToBuffer(FILE* fp, void* buf, long uncompressedLen,
|
|
||||||
long compressedLen);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Someday we might want to make this generic and handle bzip2 ".bz2"
|
|
||||||
* files too.
|
|
||||||
*
|
|
||||||
* We could declare gzip to be a sub-class of zip that has exactly
|
|
||||||
* one always-compressed entry, but we currently want to treat Zip
|
|
||||||
* and gzip as distinct, so there's no value.
|
|
||||||
*
|
|
||||||
* The zlib library has some gzip utilities, but it has no interface
|
|
||||||
* for extracting the uncompressed length of the file (you do *not*
|
|
||||||
* want to gzseek to the end).
|
|
||||||
*
|
|
||||||
* Pass in a seeked file pointer for the gzip file. If this is a gzip
|
|
||||||
* file, we set our return values appropriately and return "true" with
|
|
||||||
* the file seeked to the start of the compressed data.
|
|
||||||
*/
|
|
||||||
static bool examineGzip(FILE* fp, int* pCompressionMethod,
|
|
||||||
long* pUncompressedLen, long* pCompressedLen, unsigned long* pCRC32);
|
|
||||||
|
|
||||||
private:
|
|
||||||
ZipUtils() {}
|
|
||||||
~ZipUtils() {}
|
|
||||||
};
|
|
||||||
|
|
||||||
}; // namespace android
|
|
||||||
|
|
||||||
#endif /*__LIBS_ZIPUTILS_H*/
|
|
|
@ -20,7 +20,6 @@
|
||||||
#ifndef _LIBS_UTILS_MISC_H
|
#ifndef _LIBS_UTILS_MISC_H
|
||||||
#define _LIBS_UTILS_MISC_H
|
#define _LIBS_UTILS_MISC_H
|
||||||
|
|
||||||
#include <sys/time.h>
|
|
||||||
#include <utils/Endian.h>
|
#include <utils/Endian.h>
|
||||||
|
|
||||||
/* get #of elements in a static array */
|
/* get #of elements in a static array */
|
||||||
|
@ -30,26 +29,6 @@
|
||||||
|
|
||||||
namespace android {
|
namespace android {
|
||||||
|
|
||||||
/*
|
|
||||||
* Some utility functions for working with files. These could be made
|
|
||||||
* part of a "File" class.
|
|
||||||
*/
|
|
||||||
typedef enum FileType {
|
|
||||||
kFileTypeUnknown = 0,
|
|
||||||
kFileTypeNonexistent, // i.e. ENOENT
|
|
||||||
kFileTypeRegular,
|
|
||||||
kFileTypeDirectory,
|
|
||||||
kFileTypeCharDev,
|
|
||||||
kFileTypeBlockDev,
|
|
||||||
kFileTypeFifo,
|
|
||||||
kFileTypeSymlink,
|
|
||||||
kFileTypeSocket,
|
|
||||||
} FileType;
|
|
||||||
/* get the file's type; follows symlinks */
|
|
||||||
FileType getFileType(const char* fileName);
|
|
||||||
/* get the file's modification date; returns -1 w/errno set on failure */
|
|
||||||
time_t getFileModDate(const char* fileName);
|
|
||||||
|
|
||||||
typedef void (*sysprop_change_callback)(void);
|
typedef void (*sysprop_change_callback)(void);
|
||||||
void add_sysprop_change_callback(sysprop_change_callback cb, int priority);
|
void add_sysprop_change_callback(sysprop_change_callback cb, int priority);
|
||||||
void report_sysprop_change();
|
void report_sysprop_change();
|
||||||
|
|
|
@ -17,6 +17,8 @@ sources := \
|
||||||
AppOpsManager.cpp \
|
AppOpsManager.cpp \
|
||||||
Binder.cpp \
|
Binder.cpp \
|
||||||
BpBinder.cpp \
|
BpBinder.cpp \
|
||||||
|
BufferedTextOutput.cpp \
|
||||||
|
Debug.cpp \
|
||||||
IAppOpsCallback.cpp \
|
IAppOpsCallback.cpp \
|
||||||
IAppOpsService.cpp \
|
IAppOpsService.cpp \
|
||||||
IInterface.cpp \
|
IInterface.cpp \
|
||||||
|
@ -30,7 +32,8 @@ sources := \
|
||||||
Parcel.cpp \
|
Parcel.cpp \
|
||||||
PermissionCache.cpp \
|
PermissionCache.cpp \
|
||||||
ProcessState.cpp \
|
ProcessState.cpp \
|
||||||
Static.cpp
|
Static.cpp \
|
||||||
|
TextOutput.cpp \
|
||||||
|
|
||||||
LOCAL_PATH:= $(call my-dir)
|
LOCAL_PATH:= $(call my-dir)
|
||||||
|
|
||||||
|
|
|
@ -14,16 +14,16 @@
|
||||||
* limitations under the License.
|
* limitations under the License.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include <utils/BufferedTextOutput.h>
|
#include <binder/BufferedTextOutput.h>
|
||||||
|
#include <binder/Debug.h>
|
||||||
|
|
||||||
#include <utils/Atomic.h>
|
#include <utils/Atomic.h>
|
||||||
#include <utils/Debug.h>
|
|
||||||
#include <utils/Log.h>
|
#include <utils/Log.h>
|
||||||
#include <utils/RefBase.h>
|
#include <utils/RefBase.h>
|
||||||
#include <utils/Vector.h>
|
#include <utils/Vector.h>
|
||||||
#include <cutils/threads.h>
|
#include <cutils/threads.h>
|
||||||
|
|
||||||
#include <private/utils/Static.h>
|
#include <private/binder/Static.h>
|
||||||
|
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
|
@ -14,7 +14,7 @@
|
||||||
* limitations under the License.
|
* limitations under the License.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include <utils/Debug.h>
|
#include <binder/Debug.h>
|
||||||
|
|
||||||
#include <utils/misc.h>
|
#include <utils/misc.h>
|
||||||
|
|
||||||
|
@ -70,20 +70,6 @@ static char* appendhexnum(uint32_t val, char* out)
|
||||||
return out;
|
return out;
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline char makeupperhexdigit(uint32_t val)
|
|
||||||
{
|
|
||||||
return "0123456789ABCDEF"[val&0xF];
|
|
||||||
}
|
|
||||||
|
|
||||||
static char* appendupperhexnum(uint32_t val, char* out)
|
|
||||||
{
|
|
||||||
for( int32_t i=28; i>=0; i-=4 ) {
|
|
||||||
*out++ = makeupperhexdigit( val>>i );
|
|
||||||
}
|
|
||||||
*out = 0;
|
|
||||||
return out;
|
|
||||||
}
|
|
||||||
|
|
||||||
static char* appendcharornum(char c, char* out, bool skipzero = true)
|
static char* appendcharornum(char c, char* out, bool skipzero = true)
|
||||||
{
|
{
|
||||||
if (skipzero && c == 0) return out;
|
if (skipzero && c == 0) return out;
|
|
@ -20,10 +20,11 @@
|
||||||
|
|
||||||
#include <binder/Binder.h>
|
#include <binder/Binder.h>
|
||||||
#include <binder/BpBinder.h>
|
#include <binder/BpBinder.h>
|
||||||
|
#include <binder/TextOutput.h>
|
||||||
|
|
||||||
#include <cutils/sched_policy.h>
|
#include <cutils/sched_policy.h>
|
||||||
#include <utils/Debug.h>
|
#include <utils/Debug.h>
|
||||||
#include <utils/Log.h>
|
#include <utils/Log.h>
|
||||||
#include <utils/TextOutput.h>
|
|
||||||
#include <utils/threads.h>
|
#include <utils/threads.h>
|
||||||
|
|
||||||
#include <private/binder/binder_module.h>
|
#include <private/binder/binder_module.h>
|
||||||
|
|
|
@ -22,12 +22,13 @@
|
||||||
#include <binder/IPCThreadState.h>
|
#include <binder/IPCThreadState.h>
|
||||||
#include <binder/Binder.h>
|
#include <binder/Binder.h>
|
||||||
#include <binder/BpBinder.h>
|
#include <binder/BpBinder.h>
|
||||||
#include <utils/Debug.h>
|
|
||||||
#include <binder/ProcessState.h>
|
#include <binder/ProcessState.h>
|
||||||
|
#include <binder/TextOutput.h>
|
||||||
|
|
||||||
|
#include <utils/Debug.h>
|
||||||
#include <utils/Log.h>
|
#include <utils/Log.h>
|
||||||
#include <utils/String8.h>
|
#include <utils/String8.h>
|
||||||
#include <utils/String16.h>
|
#include <utils/String16.h>
|
||||||
#include <utils/TextOutput.h>
|
|
||||||
#include <utils/misc.h>
|
#include <utils/misc.h>
|
||||||
#include <utils/Flattenable.h>
|
#include <utils/Flattenable.h>
|
||||||
#include <cutils/ashmem.h>
|
#include <cutils/ashmem.h>
|
||||||
|
|
|
@ -19,30 +19,76 @@
|
||||||
|
|
||||||
#include <private/binder/Static.h>
|
#include <private/binder/Static.h>
|
||||||
|
|
||||||
|
#include <binder/BufferedTextOutput.h>
|
||||||
#include <binder/IPCThreadState.h>
|
#include <binder/IPCThreadState.h>
|
||||||
#include <utils/Log.h>
|
#include <utils/Log.h>
|
||||||
|
|
||||||
namespace android {
|
namespace android {
|
||||||
|
|
||||||
|
// ------------ Text output streams
|
||||||
|
|
||||||
|
Vector<int32_t> gTextBuffers;
|
||||||
|
|
||||||
|
class LogTextOutput : public BufferedTextOutput
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
LogTextOutput() : BufferedTextOutput(MULTITHREADED) { }
|
||||||
|
virtual ~LogTextOutput() { };
|
||||||
|
|
||||||
|
protected:
|
||||||
|
virtual status_t writeLines(const struct iovec& vec, size_t N)
|
||||||
|
{
|
||||||
|
//android_writevLog(&vec, N); <-- this is now a no-op
|
||||||
|
if (N != 1) ALOGI("WARNING: writeLines N=%zu\n", N);
|
||||||
|
ALOGI("%.*s", (int)vec.iov_len, (const char*) vec.iov_base);
|
||||||
|
return NO_ERROR;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class FdTextOutput : public BufferedTextOutput
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
FdTextOutput(int fd) : BufferedTextOutput(MULTITHREADED), mFD(fd) { }
|
||||||
|
virtual ~FdTextOutput() { };
|
||||||
|
|
||||||
|
protected:
|
||||||
|
virtual status_t writeLines(const struct iovec& vec, size_t N)
|
||||||
|
{
|
||||||
|
writev(mFD, &vec, N);
|
||||||
|
return NO_ERROR;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
int mFD;
|
||||||
|
};
|
||||||
|
|
||||||
|
static LogTextOutput gLogTextOutput;
|
||||||
|
static FdTextOutput gStdoutTextOutput(STDOUT_FILENO);
|
||||||
|
static FdTextOutput gStderrTextOutput(STDERR_FILENO);
|
||||||
|
|
||||||
|
TextOutput& alog(gLogTextOutput);
|
||||||
|
TextOutput& aout(gStdoutTextOutput);
|
||||||
|
TextOutput& aerr(gStderrTextOutput);
|
||||||
|
|
||||||
// ------------ ProcessState.cpp
|
// ------------ ProcessState.cpp
|
||||||
|
|
||||||
Mutex gProcessMutex;
|
Mutex gProcessMutex;
|
||||||
sp<ProcessState> gProcess;
|
sp<ProcessState> gProcess;
|
||||||
|
|
||||||
class LibUtilsIPCtStatics
|
class LibBinderIPCtStatics
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
LibUtilsIPCtStatics()
|
LibBinderIPCtStatics()
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
~LibUtilsIPCtStatics()
|
~LibBinderIPCtStatics()
|
||||||
{
|
{
|
||||||
IPCThreadState::shutdown();
|
IPCThreadState::shutdown();
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
static LibUtilsIPCtStatics gIPCStatics;
|
static LibBinderIPCtStatics gIPCStatics;
|
||||||
|
|
||||||
// ------------ ServiceManager.cpp
|
// ------------ ServiceManager.cpp
|
||||||
|
|
||||||
|
|
|
@ -14,9 +14,9 @@
|
||||||
* limitations under the License.
|
* limitations under the License.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include <utils/TextOutput.h>
|
#include <binder/TextOutput.h>
|
||||||
|
|
||||||
#include <utils/Debug.h>
|
#include <binder/Debug.h>
|
||||||
|
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
|
@ -20,9 +20,7 @@ LOCAL_PATH:= $(call my-dir)
|
||||||
commonSources:= \
|
commonSources:= \
|
||||||
BasicHashtable.cpp \
|
BasicHashtable.cpp \
|
||||||
BlobCache.cpp \
|
BlobCache.cpp \
|
||||||
BufferedTextOutput.cpp \
|
|
||||||
CallStack.cpp \
|
CallStack.cpp \
|
||||||
Debug.cpp \
|
|
||||||
FileMap.cpp \
|
FileMap.cpp \
|
||||||
Flattenable.cpp \
|
Flattenable.cpp \
|
||||||
JenkinsHash.cpp \
|
JenkinsHash.cpp \
|
||||||
|
@ -36,18 +34,12 @@ commonSources:= \
|
||||||
StopWatch.cpp \
|
StopWatch.cpp \
|
||||||
String8.cpp \
|
String8.cpp \
|
||||||
String16.cpp \
|
String16.cpp \
|
||||||
StringArray.cpp \
|
|
||||||
SystemClock.cpp \
|
SystemClock.cpp \
|
||||||
TextOutput.cpp \
|
|
||||||
Threads.cpp \
|
Threads.cpp \
|
||||||
Timers.cpp \
|
Timers.cpp \
|
||||||
Tokenizer.cpp \
|
Tokenizer.cpp \
|
||||||
Unicode.cpp \
|
Unicode.cpp \
|
||||||
VectorImpl.cpp \
|
VectorImpl.cpp \
|
||||||
WorkQueue.cpp \
|
|
||||||
ZipFileCRO.cpp \
|
|
||||||
ZipFileRO.cpp \
|
|
||||||
ZipUtils.cpp \
|
|
||||||
misc.cpp
|
misc.cpp
|
||||||
|
|
||||||
host_commonCflags := -DLIBUTILS_NATIVE=1 $(TOOL_CFLAGS)
|
host_commonCflags := -DLIBUTILS_NATIVE=1 $(TOOL_CFLAGS)
|
||||||
|
@ -74,9 +66,6 @@ ifeq ($(HOST_OS), linux)
|
||||||
LOCAL_SRC_FILES += Looper.cpp
|
LOCAL_SRC_FILES += Looper.cpp
|
||||||
endif
|
endif
|
||||||
LOCAL_MODULE:= libutils
|
LOCAL_MODULE:= libutils
|
||||||
LOCAL_STATIC_LIBRARIES := libz
|
|
||||||
LOCAL_C_INCLUDES := \
|
|
||||||
external/zlib
|
|
||||||
LOCAL_CFLAGS += $(host_commonCflags)
|
LOCAL_CFLAGS += $(host_commonCflags)
|
||||||
LOCAL_LDLIBS += $(host_commonLdlibs)
|
LOCAL_LDLIBS += $(host_commonLdlibs)
|
||||||
include $(BUILD_HOST_STATIC_LIBRARY)
|
include $(BUILD_HOST_STATIC_LIBRARY)
|
||||||
|
@ -90,9 +79,6 @@ ifeq ($(HOST_OS), linux)
|
||||||
LOCAL_SRC_FILES += Looper.cpp
|
LOCAL_SRC_FILES += Looper.cpp
|
||||||
endif
|
endif
|
||||||
LOCAL_MODULE:= lib64utils
|
LOCAL_MODULE:= lib64utils
|
||||||
LOCAL_STATIC_LIBRARIES := libz
|
|
||||||
LOCAL_C_INCLUDES := \
|
|
||||||
external/zlib
|
|
||||||
LOCAL_CFLAGS += $(host_commonCflags) -m64
|
LOCAL_CFLAGS += $(host_commonCflags) -m64
|
||||||
LOCAL_LDLIBS += $(host_commonLdlibs)
|
LOCAL_LDLIBS += $(host_commonLdlibs)
|
||||||
include $(BUILD_HOST_STATIC_LIBRARY)
|
include $(BUILD_HOST_STATIC_LIBRARY)
|
||||||
|
@ -124,8 +110,7 @@ LOCAL_C_INCLUDES += \
|
||||||
LOCAL_LDLIBS += -lpthread
|
LOCAL_LDLIBS += -lpthread
|
||||||
|
|
||||||
LOCAL_STATIC_LIBRARIES := \
|
LOCAL_STATIC_LIBRARIES := \
|
||||||
libcutils \
|
libcutils
|
||||||
libz
|
|
||||||
|
|
||||||
LOCAL_SHARED_LIBRARIES := \
|
LOCAL_SHARED_LIBRARIES := \
|
||||||
libcorkscrew \
|
libcorkscrew \
|
||||||
|
@ -144,8 +129,8 @@ LOCAL_SHARED_LIBRARIES := \
|
||||||
liblog \
|
liblog \
|
||||||
libcutils \
|
libcutils \
|
||||||
libdl \
|
libdl \
|
||||||
libcorkscrew \
|
libcorkscrew
|
||||||
libz
|
|
||||||
include $(BUILD_SHARED_LIBRARY)
|
include $(BUILD_SHARED_LIBRARY)
|
||||||
|
|
||||||
# Include subdirectory makefiles
|
# Include subdirectory makefiles
|
||||||
|
|
|
@ -23,7 +23,6 @@
|
||||||
#include <utils/CallStack.h>
|
#include <utils/CallStack.h>
|
||||||
#include <utils/Log.h>
|
#include <utils/Log.h>
|
||||||
#include <utils/threads.h>
|
#include <utils/threads.h>
|
||||||
#include <utils/TextOutput.h>
|
|
||||||
|
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
|
@ -648,19 +647,4 @@ void RefBase::renameRefId(RefBase* ref,
|
||||||
ref->mRefs->renameWeakRefId(old_id, new_id);
|
ref->mRefs->renameWeakRefId(old_id, new_id);
|
||||||
}
|
}
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
TextOutput& printStrongPointer(TextOutput& to, const void* val)
|
|
||||||
{
|
|
||||||
to << "sp<>(" << val << ")";
|
|
||||||
return to;
|
|
||||||
}
|
|
||||||
|
|
||||||
TextOutput& printWeakPointer(TextOutput& to, const void* val)
|
|
||||||
{
|
|
||||||
to << "wp<>(" << val << ")";
|
|
||||||
return to;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}; // namespace android
|
}; // namespace android
|
||||||
|
|
|
@ -17,13 +17,16 @@
|
||||||
// All static variables go here, to control initialization and
|
// All static variables go here, to control initialization and
|
||||||
// destruction order in the library.
|
// destruction order in the library.
|
||||||
|
|
||||||
#include <private/utils/Static.h>
|
|
||||||
|
|
||||||
#include <utils/BufferedTextOutput.h>
|
|
||||||
#include <utils/Log.h>
|
|
||||||
|
|
||||||
namespace android {
|
namespace android {
|
||||||
|
|
||||||
|
// For String8.cpp
|
||||||
|
extern void initialize_string8();
|
||||||
|
extern void terminate_string8();
|
||||||
|
|
||||||
|
// For String16.cpp
|
||||||
|
extern void initialize_string16();
|
||||||
|
extern void terminate_string16();
|
||||||
|
|
||||||
class LibUtilsFirstStatics
|
class LibUtilsFirstStatics
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
|
@ -43,49 +46,4 @@ public:
|
||||||
static LibUtilsFirstStatics gFirstStatics;
|
static LibUtilsFirstStatics gFirstStatics;
|
||||||
int gDarwinCantLoadAllObjects = 1;
|
int gDarwinCantLoadAllObjects = 1;
|
||||||
|
|
||||||
// ------------ Text output streams
|
|
||||||
|
|
||||||
Vector<int32_t> gTextBuffers;
|
|
||||||
|
|
||||||
class LogTextOutput : public BufferedTextOutput
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
LogTextOutput() : BufferedTextOutput(MULTITHREADED) { }
|
|
||||||
virtual ~LogTextOutput() { };
|
|
||||||
|
|
||||||
protected:
|
|
||||||
virtual status_t writeLines(const struct iovec& vec, size_t N)
|
|
||||||
{
|
|
||||||
//android_writevLog(&vec, N); <-- this is now a no-op
|
|
||||||
if (N != 1) ALOGI("WARNING: writeLines N=%zu\n", N);
|
|
||||||
ALOGI("%.*s", (int)vec.iov_len, (const char*) vec.iov_base);
|
|
||||||
return NO_ERROR;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
class FdTextOutput : public BufferedTextOutput
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
FdTextOutput(int fd) : BufferedTextOutput(MULTITHREADED), mFD(fd) { }
|
|
||||||
virtual ~FdTextOutput() { };
|
|
||||||
|
|
||||||
protected:
|
|
||||||
virtual status_t writeLines(const struct iovec& vec, size_t N)
|
|
||||||
{
|
|
||||||
writev(mFD, &vec, N);
|
|
||||||
return NO_ERROR;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
int mFD;
|
|
||||||
};
|
|
||||||
|
|
||||||
static LogTextOutput gLogTextOutput;
|
|
||||||
static FdTextOutput gStdoutTextOutput(STDOUT_FILENO);
|
|
||||||
static FdTextOutput gStderrTextOutput(STDERR_FILENO);
|
|
||||||
|
|
||||||
TextOutput& alog(gLogTextOutput);
|
|
||||||
TextOutput& aout(gStdoutTextOutput);
|
|
||||||
TextOutput& aerr(gStderrTextOutput);
|
|
||||||
|
|
||||||
} // namespace android
|
} // namespace android
|
||||||
|
|
|
@ -20,11 +20,8 @@
|
||||||
#include <utils/Log.h>
|
#include <utils/Log.h>
|
||||||
#include <utils/Unicode.h>
|
#include <utils/Unicode.h>
|
||||||
#include <utils/String8.h>
|
#include <utils/String8.h>
|
||||||
#include <utils/TextOutput.h>
|
|
||||||
#include <utils/threads.h>
|
#include <utils/threads.h>
|
||||||
|
|
||||||
#include <private/utils/Static.h>
|
|
||||||
|
|
||||||
#include <memory.h>
|
#include <memory.h>
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#include <ctype.h>
|
#include <ctype.h>
|
||||||
|
@ -409,10 +406,4 @@ status_t String16::remove(size_t len, size_t begin)
|
||||||
return NO_MEMORY;
|
return NO_MEMORY;
|
||||||
}
|
}
|
||||||
|
|
||||||
TextOutput& operator<<(TextOutput& to, const String16& val)
|
|
||||||
{
|
|
||||||
to << String8(val).string();
|
|
||||||
return to;
|
|
||||||
}
|
|
||||||
|
|
||||||
}; // namespace android
|
}; // namespace android
|
||||||
|
|
|
@ -20,11 +20,8 @@
|
||||||
#include <utils/Unicode.h>
|
#include <utils/Unicode.h>
|
||||||
#include <utils/SharedBuffer.h>
|
#include <utils/SharedBuffer.h>
|
||||||
#include <utils/String16.h>
|
#include <utils/String16.h>
|
||||||
#include <utils/TextOutput.h>
|
|
||||||
#include <utils/threads.h>
|
#include <utils/threads.h>
|
||||||
|
|
||||||
#include <private/utils/Static.h>
|
|
||||||
|
|
||||||
#include <ctype.h>
|
#include <ctype.h>
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
@ -46,6 +43,8 @@ static char* gEmptyString = NULL;
|
||||||
extern int gDarwinCantLoadAllObjects;
|
extern int gDarwinCantLoadAllObjects;
|
||||||
int gDarwinIsReallyAnnoying;
|
int gDarwinIsReallyAnnoying;
|
||||||
|
|
||||||
|
void initialize_string8();
|
||||||
|
|
||||||
static inline char* getEmptyString()
|
static inline char* getEmptyString()
|
||||||
{
|
{
|
||||||
if (!gEmptyStringBuf) initialize_string8();
|
if (!gEmptyStringBuf) initialize_string8();
|
||||||
|
@ -454,12 +453,6 @@ void String8::getUtf32(char32_t* dst) const
|
||||||
utf8_to_utf32(mString, length(), dst);
|
utf8_to_utf32(mString, length(), dst);
|
||||||
}
|
}
|
||||||
|
|
||||||
TextOutput& operator<<(TextOutput& to, const String8& val)
|
|
||||||
{
|
|
||||||
to << val.string();
|
|
||||||
return to;
|
|
||||||
}
|
|
||||||
|
|
||||||
// ---------------------------------------------------------------------------
|
// ---------------------------------------------------------------------------
|
||||||
// Path functions
|
// Path functions
|
||||||
|
|
||||||
|
|
|
@ -1,113 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//
|
|
||||||
// Sortable array of strings. STL-ish, but STL-free.
|
|
||||||
//
|
|
||||||
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include <utils/StringArray.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
|
|
||||||
//
|
|
||||||
// An expanding array of strings. Add, get, sort, delete.
|
|
||||||
//
|
|
||||||
StringArray::StringArray()
|
|
||||||
: mMax(0), mCurrent(0), mArray(NULL)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
StringArray:: ~StringArray() {
|
|
||||||
for (int i = 0; i < mCurrent; i++)
|
|
||||||
delete[] mArray[i];
|
|
||||||
delete[] mArray;
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// Add a string. A copy of the string is made.
|
|
||||||
//
|
|
||||||
bool StringArray::push_back(const char* str) {
|
|
||||||
if (mCurrent >= mMax) {
|
|
||||||
char** tmp;
|
|
||||||
|
|
||||||
if (mMax == 0)
|
|
||||||
mMax = 16; // initial storage
|
|
||||||
else
|
|
||||||
mMax *= 2;
|
|
||||||
|
|
||||||
tmp = new char*[mMax];
|
|
||||||
if (tmp == NULL)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
memcpy(tmp, mArray, mCurrent * sizeof(char*));
|
|
||||||
delete[] mArray;
|
|
||||||
mArray = tmp;
|
|
||||||
}
|
|
||||||
|
|
||||||
int len = strlen(str);
|
|
||||||
mArray[mCurrent] = new char[len+1];
|
|
||||||
memcpy(mArray[mCurrent], str, len+1);
|
|
||||||
mCurrent++;
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// Delete an entry.
|
|
||||||
//
|
|
||||||
void StringArray::erase(int idx) {
|
|
||||||
if (idx < 0 || idx >= mCurrent)
|
|
||||||
return;
|
|
||||||
delete[] mArray[idx];
|
|
||||||
if (idx < mCurrent-1) {
|
|
||||||
memmove(&mArray[idx], &mArray[idx+1],
|
|
||||||
(mCurrent-1 - idx) * sizeof(char*));
|
|
||||||
}
|
|
||||||
mCurrent--;
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// Sort the array.
|
|
||||||
//
|
|
||||||
void StringArray::sort(int (*compare)(const void*, const void*)) {
|
|
||||||
qsort(mArray, mCurrent, sizeof(char*), compare);
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// Pass this to the sort routine to do an ascending alphabetical sort.
|
|
||||||
//
|
|
||||||
int StringArray::cmpAscendingAlpha(const void* pstr1, const void* pstr2) {
|
|
||||||
return strcmp(*(const char**)pstr1, *(const char**)pstr2);
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
// Set entry N to specified string.
|
|
||||||
// [should use operator[] here]
|
|
||||||
//
|
|
||||||
void StringArray::setEntry(int idx, const char* str) {
|
|
||||||
if (idx < 0 || idx >= mCurrent)
|
|
||||||
return;
|
|
||||||
delete[] mArray[idx];
|
|
||||||
int len = strlen(str);
|
|
||||||
mArray[idx] = new char[len+1];
|
|
||||||
memcpy(mArray[idx], str, len+1);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
}; // namespace android
|
|
|
@ -36,62 +36,10 @@
|
||||||
#include <utils/Timers.h>
|
#include <utils/Timers.h>
|
||||||
|
|
||||||
#define LOG_TAG "SystemClock"
|
#define LOG_TAG "SystemClock"
|
||||||
#include "utils/Log.h"
|
#include <utils/Log.h>
|
||||||
|
|
||||||
namespace android {
|
namespace android {
|
||||||
|
|
||||||
/*
|
|
||||||
* Set the current time. This only works when running as root.
|
|
||||||
*/
|
|
||||||
int setCurrentTimeMillis(int64_t millis)
|
|
||||||
{
|
|
||||||
#if WIN32
|
|
||||||
// not implemented
|
|
||||||
return -1;
|
|
||||||
#else
|
|
||||||
struct timeval tv;
|
|
||||||
#ifdef HAVE_ANDROID_OS
|
|
||||||
struct timespec ts;
|
|
||||||
int fd;
|
|
||||||
int res;
|
|
||||||
#endif
|
|
||||||
int ret = 0;
|
|
||||||
|
|
||||||
if (millis <= 0 || millis / 1000LL >= INT_MAX) {
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
tv.tv_sec = (time_t) (millis / 1000LL);
|
|
||||||
tv.tv_usec = (suseconds_t) ((millis % 1000LL) * 1000LL);
|
|
||||||
|
|
||||||
ALOGD("Setting time of day to sec=%d\n", (int) tv.tv_sec);
|
|
||||||
|
|
||||||
#ifdef HAVE_ANDROID_OS
|
|
||||||
fd = open("/dev/alarm", O_RDWR);
|
|
||||||
if(fd < 0) {
|
|
||||||
ALOGW("Unable to open alarm driver: %s\n", strerror(errno));
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
ts.tv_sec = tv.tv_sec;
|
|
||||||
ts.tv_nsec = tv.tv_usec * 1000;
|
|
||||||
res = ioctl(fd, ANDROID_ALARM_SET_RTC, &ts);
|
|
||||||
if(res < 0) {
|
|
||||||
ALOGW("Unable to set rtc to %ld: %s\n", tv.tv_sec, strerror(errno));
|
|
||||||
ret = -1;
|
|
||||||
}
|
|
||||||
close(fd);
|
|
||||||
#else
|
|
||||||
if (settimeofday(&tv, NULL) != 0) {
|
|
||||||
ALOGW("Unable to set clock to %d.%d: %s\n",
|
|
||||||
(int) tv.tv_sec, (int) tv.tv_usec, strerror(errno));
|
|
||||||
ret = -1;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
#endif // WIN32
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* native public static long uptimeMillis();
|
* native public static long uptimeMillis();
|
||||||
*/
|
*/
|
||||||
|
|
|
@ -70,65 +70,3 @@ int toMillisecondTimeoutDelay(nsecs_t referenceTime, nsecs_t timeoutTime)
|
||||||
}
|
}
|
||||||
return timeoutDelayMillis;
|
return timeoutDelayMillis;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* ===========================================================================
|
|
||||||
* DurationTimer
|
|
||||||
* ===========================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
using namespace android;
|
|
||||||
|
|
||||||
// Start the timer.
|
|
||||||
void DurationTimer::start(void)
|
|
||||||
{
|
|
||||||
gettimeofday(&mStartWhen, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Stop the timer.
|
|
||||||
void DurationTimer::stop(void)
|
|
||||||
{
|
|
||||||
gettimeofday(&mStopWhen, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get the duration in microseconds.
|
|
||||||
long long DurationTimer::durationUsecs(void) const
|
|
||||||
{
|
|
||||||
return (long) subtractTimevals(&mStopWhen, &mStartWhen);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Subtract two timevals. Returns the difference (ptv1-ptv2) in
|
|
||||||
// microseconds.
|
|
||||||
/*static*/ long long DurationTimer::subtractTimevals(const struct timeval* ptv1,
|
|
||||||
const struct timeval* ptv2)
|
|
||||||
{
|
|
||||||
long long stop = ((long long) ptv1->tv_sec) * 1000000LL +
|
|
||||||
((long long) ptv1->tv_usec);
|
|
||||||
long long start = ((long long) ptv2->tv_sec) * 1000000LL +
|
|
||||||
((long long) ptv2->tv_usec);
|
|
||||||
return stop - start;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add the specified amount of time to the timeval.
|
|
||||||
/*static*/ void DurationTimer::addToTimeval(struct timeval* ptv, long usec)
|
|
||||||
{
|
|
||||||
if (usec < 0) {
|
|
||||||
ALOG(LOG_WARN, "", "Negative values not supported in addToTimeval\n");
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
// normalize tv_usec if necessary
|
|
||||||
if (ptv->tv_usec >= 1000000) {
|
|
||||||
ptv->tv_sec += ptv->tv_usec / 1000000;
|
|
||||||
ptv->tv_usec %= 1000000;
|
|
||||||
}
|
|
||||||
|
|
||||||
ptv->tv_usec += usec % 1000000;
|
|
||||||
if (ptv->tv_usec >= 1000000) {
|
|
||||||
ptv->tv_usec -= 1000000;
|
|
||||||
ptv->tv_sec++;
|
|
||||||
}
|
|
||||||
ptv->tv_sec += usec / 1000000;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,171 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 2012 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
// #define LOG_NDEBUG 0
|
|
||||||
#define LOG_TAG "WorkQueue"
|
|
||||||
|
|
||||||
#include <utils/Log.h>
|
|
||||||
#include <utils/WorkQueue.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
|
|
||||||
// --- WorkQueue ---
|
|
||||||
|
|
||||||
WorkQueue::WorkQueue(size_t maxThreads, bool canCallJava) :
|
|
||||||
mMaxThreads(maxThreads), mCanCallJava(canCallJava),
|
|
||||||
mCanceled(false), mFinished(false), mIdleThreads(0) {
|
|
||||||
}
|
|
||||||
|
|
||||||
WorkQueue::~WorkQueue() {
|
|
||||||
if (!cancel()) {
|
|
||||||
finish();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
status_t WorkQueue::schedule(WorkUnit* workUnit, size_t backlog) {
|
|
||||||
AutoMutex _l(mLock);
|
|
||||||
|
|
||||||
if (mFinished || mCanceled) {
|
|
||||||
return INVALID_OPERATION;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (mWorkThreads.size() < mMaxThreads
|
|
||||||
&& mIdleThreads < mWorkUnits.size() + 1) {
|
|
||||||
sp<WorkThread> workThread = new WorkThread(this, mCanCallJava);
|
|
||||||
status_t status = workThread->run("WorkQueue::WorkThread");
|
|
||||||
if (status) {
|
|
||||||
return status;
|
|
||||||
}
|
|
||||||
mWorkThreads.add(workThread);
|
|
||||||
mIdleThreads += 1;
|
|
||||||
} else if (backlog) {
|
|
||||||
while (mWorkUnits.size() >= mMaxThreads * backlog) {
|
|
||||||
mWorkDequeuedCondition.wait(mLock);
|
|
||||||
if (mFinished || mCanceled) {
|
|
||||||
return INVALID_OPERATION;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
mWorkUnits.add(workUnit);
|
|
||||||
mWorkChangedCondition.broadcast();
|
|
||||||
return OK;
|
|
||||||
}
|
|
||||||
|
|
||||||
status_t WorkQueue::cancel() {
|
|
||||||
AutoMutex _l(mLock);
|
|
||||||
|
|
||||||
return cancelLocked();
|
|
||||||
}
|
|
||||||
|
|
||||||
status_t WorkQueue::cancelLocked() {
|
|
||||||
if (mFinished) {
|
|
||||||
return INVALID_OPERATION;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!mCanceled) {
|
|
||||||
mCanceled = true;
|
|
||||||
|
|
||||||
size_t count = mWorkUnits.size();
|
|
||||||
for (size_t i = 0; i < count; i++) {
|
|
||||||
delete mWorkUnits.itemAt(i);
|
|
||||||
}
|
|
||||||
mWorkUnits.clear();
|
|
||||||
mWorkChangedCondition.broadcast();
|
|
||||||
mWorkDequeuedCondition.broadcast();
|
|
||||||
}
|
|
||||||
return OK;
|
|
||||||
}
|
|
||||||
|
|
||||||
status_t WorkQueue::finish() {
|
|
||||||
{ // acquire lock
|
|
||||||
AutoMutex _l(mLock);
|
|
||||||
|
|
||||||
if (mFinished) {
|
|
||||||
return INVALID_OPERATION;
|
|
||||||
}
|
|
||||||
|
|
||||||
mFinished = true;
|
|
||||||
mWorkChangedCondition.broadcast();
|
|
||||||
} // release lock
|
|
||||||
|
|
||||||
// It is not possible for the list of work threads to change once the mFinished
|
|
||||||
// flag has been set, so we can access mWorkThreads outside of the lock here.
|
|
||||||
size_t count = mWorkThreads.size();
|
|
||||||
for (size_t i = 0; i < count; i++) {
|
|
||||||
mWorkThreads.itemAt(i)->join();
|
|
||||||
}
|
|
||||||
mWorkThreads.clear();
|
|
||||||
return OK;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool WorkQueue::threadLoop() {
|
|
||||||
WorkUnit* workUnit;
|
|
||||||
{ // acquire lock
|
|
||||||
AutoMutex _l(mLock);
|
|
||||||
|
|
||||||
for (;;) {
|
|
||||||
if (mCanceled) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!mWorkUnits.isEmpty()) {
|
|
||||||
workUnit = mWorkUnits.itemAt(0);
|
|
||||||
mWorkUnits.removeAt(0);
|
|
||||||
mIdleThreads -= 1;
|
|
||||||
mWorkDequeuedCondition.broadcast();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (mFinished) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
mWorkChangedCondition.wait(mLock);
|
|
||||||
}
|
|
||||||
} // release lock
|
|
||||||
|
|
||||||
bool shouldContinue = workUnit->run();
|
|
||||||
delete workUnit;
|
|
||||||
|
|
||||||
{ // acquire lock
|
|
||||||
AutoMutex _l(mLock);
|
|
||||||
|
|
||||||
mIdleThreads += 1;
|
|
||||||
|
|
||||||
if (!shouldContinue) {
|
|
||||||
cancelLocked();
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
} // release lock
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
// --- WorkQueue::WorkThread ---
|
|
||||||
|
|
||||||
WorkQueue::WorkThread::WorkThread(WorkQueue* workQueue, bool canCallJava) :
|
|
||||||
Thread(canCallJava), mWorkQueue(workQueue) {
|
|
||||||
}
|
|
||||||
|
|
||||||
WorkQueue::WorkThread::~WorkThread() {
|
|
||||||
}
|
|
||||||
|
|
||||||
bool WorkQueue::WorkThread::threadLoop() {
|
|
||||||
return mWorkQueue->threadLoop();
|
|
||||||
}
|
|
||||||
|
|
||||||
}; // namespace android
|
|
|
@ -1,54 +0,0 @@
|
||||||
/*
|
|
||||||
* 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 <utils/ZipFileCRO.h>
|
|
||||||
#include <utils/ZipFileRO.h>
|
|
||||||
|
|
||||||
using namespace android;
|
|
||||||
|
|
||||||
ZipFileCRO ZipFileXRO_open(const char* path) {
|
|
||||||
ZipFileRO* zip = new ZipFileRO();
|
|
||||||
if (zip->open(path) == NO_ERROR) {
|
|
||||||
return (ZipFileCRO)zip;
|
|
||||||
}
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ZipFileCRO_destroy(ZipFileCRO zipToken) {
|
|
||||||
ZipFileRO* zip = (ZipFileRO*)zipToken;
|
|
||||||
delete zip;
|
|
||||||
}
|
|
||||||
|
|
||||||
ZipEntryCRO ZipFileCRO_findEntryByName(ZipFileCRO zipToken,
|
|
||||||
const char* fileName) {
|
|
||||||
ZipFileRO* zip = (ZipFileRO*)zipToken;
|
|
||||||
return (ZipEntryCRO)zip->findEntryByName(fileName);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ZipFileCRO_getEntryInfo(ZipFileCRO zipToken, ZipEntryRO entryToken,
|
|
||||||
int* pMethod, size_t* pUncompLen,
|
|
||||||
size_t* pCompLen, off64_t* pOffset, long* pModWhen, long* pCrc32) {
|
|
||||||
ZipFileRO* zip = (ZipFileRO*)zipToken;
|
|
||||||
ZipEntryRO entry = (ZipEntryRO)entryToken;
|
|
||||||
return zip->getEntryInfo(entry, pMethod, pUncompLen, pCompLen, pOffset,
|
|
||||||
pModWhen, pCrc32);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ZipFileCRO_uncompressEntry(ZipFileCRO zipToken, ZipEntryRO entryToken, int fd) {
|
|
||||||
ZipFileRO* zip = (ZipFileRO*)zipToken;
|
|
||||||
ZipEntryRO entry = (ZipEntryRO)entryToken;
|
|
||||||
return zip->uncompressEntry(entry, fd);
|
|
||||||
}
|
|
|
@ -1,931 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 2007 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//
|
|
||||||
// Read-only access to Zip archives, with minimal heap allocation.
|
|
||||||
//
|
|
||||||
#define LOG_TAG "zipro"
|
|
||||||
//#define LOG_NDEBUG 0
|
|
||||||
#include <utils/Log.h>
|
|
||||||
#include <utils/Compat.h>
|
|
||||||
#include <utils/ZipFileRO.h>
|
|
||||||
#include <utils/misc.h>
|
|
||||||
#include <utils/threads.h>
|
|
||||||
|
|
||||||
#include <zlib.h>
|
|
||||||
|
|
||||||
#include <string.h>
|
|
||||||
#include <fcntl.h>
|
|
||||||
#include <errno.h>
|
|
||||||
#include <assert.h>
|
|
||||||
#include <unistd.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* We must open binary files using open(path, ... | O_BINARY) under Windows.
|
|
||||||
* Otherwise strange read errors will happen.
|
|
||||||
*/
|
|
||||||
#ifndef O_BINARY
|
|
||||||
# define O_BINARY 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
using namespace android;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Zip file constants.
|
|
||||||
*/
|
|
||||||
#define kEOCDSignature 0x06054b50
|
|
||||||
#define kEOCDLen 22
|
|
||||||
#define kEOCDNumEntries 8 // offset to #of entries in file
|
|
||||||
#define kEOCDSize 12 // size of the central directory
|
|
||||||
#define kEOCDFileOffset 16 // offset to central directory
|
|
||||||
|
|
||||||
#define kMaxCommentLen 65535 // longest possible in ushort
|
|
||||||
#define kMaxEOCDSearch (kMaxCommentLen + kEOCDLen)
|
|
||||||
|
|
||||||
#define kLFHSignature 0x04034b50
|
|
||||||
#define kLFHLen 30 // excluding variable-len fields
|
|
||||||
#define kLFHNameLen 26 // offset to filename length
|
|
||||||
#define kLFHExtraLen 28 // offset to extra length
|
|
||||||
|
|
||||||
#define kCDESignature 0x02014b50
|
|
||||||
#define kCDELen 46 // excluding variable-len fields
|
|
||||||
#define kCDEMethod 10 // offset to compression method
|
|
||||||
#define kCDEModWhen 12 // offset to modification timestamp
|
|
||||||
#define kCDECRC 16 // offset to entry CRC
|
|
||||||
#define kCDECompLen 20 // offset to compressed length
|
|
||||||
#define kCDEUncompLen 24 // offset to uncompressed length
|
|
||||||
#define kCDENameLen 28 // offset to filename length
|
|
||||||
#define kCDEExtraLen 30 // offset to extra length
|
|
||||||
#define kCDECommentLen 32 // offset to comment length
|
|
||||||
#define kCDELocalOffset 42 // offset to local hdr
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The values we return for ZipEntryRO use 0 as an invalid value, so we
|
|
||||||
* want to adjust the hash table index by a fixed amount. Using a large
|
|
||||||
* value helps insure that people don't mix & match arguments, e.g. to
|
|
||||||
* findEntryByIndex().
|
|
||||||
*/
|
|
||||||
#define kZipEntryAdj 10000
|
|
||||||
|
|
||||||
ZipFileRO::~ZipFileRO() {
|
|
||||||
free(mHashTable);
|
|
||||||
if (mDirectoryMap)
|
|
||||||
mDirectoryMap->release();
|
|
||||||
if (mFd >= 0)
|
|
||||||
TEMP_FAILURE_RETRY(close(mFd));
|
|
||||||
if (mFileName)
|
|
||||||
free(mFileName);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Convert a ZipEntryRO to a hash table index, verifying that it's in a
|
|
||||||
* valid range.
|
|
||||||
*/
|
|
||||||
int ZipFileRO::entryToIndex(const ZipEntryRO entry) const
|
|
||||||
{
|
|
||||||
long ent = ((intptr_t) entry) - kZipEntryAdj;
|
|
||||||
if (ent < 0 || ent >= mHashTableSize || mHashTable[ent].name == NULL) {
|
|
||||||
ALOGW("Invalid ZipEntryRO %p (%ld)\n", entry, ent);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
return ent;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Open the specified file read-only. We memory-map the entire thing and
|
|
||||||
* close the file before returning.
|
|
||||||
*/
|
|
||||||
status_t ZipFileRO::open(const char* zipFileName)
|
|
||||||
{
|
|
||||||
int fd = -1;
|
|
||||||
|
|
||||||
assert(mDirectoryMap == NULL);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Open and map the specified file.
|
|
||||||
*/
|
|
||||||
fd = TEMP_FAILURE_RETRY(::open(zipFileName, O_RDONLY | O_BINARY));
|
|
||||||
if (fd < 0) {
|
|
||||||
ALOGW("Unable to open zip '%s': %s\n", zipFileName, strerror(errno));
|
|
||||||
return NAME_NOT_FOUND;
|
|
||||||
}
|
|
||||||
|
|
||||||
mFileLength = lseek64(fd, 0, SEEK_END);
|
|
||||||
if (mFileLength < kEOCDLen) {
|
|
||||||
TEMP_FAILURE_RETRY(close(fd));
|
|
||||||
return UNKNOWN_ERROR;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (mFileName != NULL) {
|
|
||||||
free(mFileName);
|
|
||||||
}
|
|
||||||
mFileName = strdup(zipFileName);
|
|
||||||
|
|
||||||
mFd = fd;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Find the Central Directory and store its size and number of entries.
|
|
||||||
*/
|
|
||||||
if (!mapCentralDirectory()) {
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Verify Central Directory and create data structures for fast access.
|
|
||||||
*/
|
|
||||||
if (!parseZipArchive()) {
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
return OK;
|
|
||||||
|
|
||||||
bail:
|
|
||||||
free(mFileName);
|
|
||||||
mFileName = NULL;
|
|
||||||
TEMP_FAILURE_RETRY(close(fd));
|
|
||||||
return UNKNOWN_ERROR;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Parse the Zip archive, verifying its contents and initializing internal
|
|
||||||
* data structures.
|
|
||||||
*/
|
|
||||||
bool ZipFileRO::mapCentralDirectory(void)
|
|
||||||
{
|
|
||||||
ssize_t readAmount = kMaxEOCDSearch;
|
|
||||||
if (readAmount > (ssize_t) mFileLength)
|
|
||||||
readAmount = mFileLength;
|
|
||||||
|
|
||||||
unsigned char* scanBuf = (unsigned char*) malloc(readAmount);
|
|
||||||
if (scanBuf == NULL) {
|
|
||||||
ALOGW("couldn't allocate scanBuf: %s", strerror(errno));
|
|
||||||
free(scanBuf);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Make sure this is a Zip archive.
|
|
||||||
*/
|
|
||||||
if (lseek64(mFd, 0, SEEK_SET) != 0) {
|
|
||||||
ALOGW("seek to start failed: %s", strerror(errno));
|
|
||||||
free(scanBuf);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t actual = TEMP_FAILURE_RETRY(read(mFd, scanBuf, sizeof(int32_t)));
|
|
||||||
if (actual != (ssize_t) sizeof(int32_t)) {
|
|
||||||
ALOGI("couldn't read first signature from zip archive: %s", strerror(errno));
|
|
||||||
free(scanBuf);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
{
|
|
||||||
unsigned int header = get4LE(scanBuf);
|
|
||||||
if (header == kEOCDSignature) {
|
|
||||||
ALOGI("Found Zip archive, but it looks empty\n");
|
|
||||||
free(scanBuf);
|
|
||||||
return false;
|
|
||||||
} else if (header != kLFHSignature) {
|
|
||||||
ALOGV("Not a Zip archive (found 0x%08x)\n", header);
|
|
||||||
free(scanBuf);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Perform the traditional EOCD snipe hunt.
|
|
||||||
*
|
|
||||||
* We're searching for the End of Central Directory magic number,
|
|
||||||
* which appears at the start of the EOCD block. It's followed by
|
|
||||||
* 18 bytes of EOCD stuff and up to 64KB of archive comment. We
|
|
||||||
* need to read the last part of the file into a buffer, dig through
|
|
||||||
* it to find the magic number, parse some values out, and use those
|
|
||||||
* to determine the extent of the CD.
|
|
||||||
*
|
|
||||||
* We start by pulling in the last part of the file.
|
|
||||||
*/
|
|
||||||
off64_t searchStart = mFileLength - readAmount;
|
|
||||||
|
|
||||||
if (lseek64(mFd, searchStart, SEEK_SET) != searchStart) {
|
|
||||||
ALOGW("seek %ld failed: %s\n", (long) searchStart, strerror(errno));
|
|
||||||
free(scanBuf);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
actual = TEMP_FAILURE_RETRY(read(mFd, scanBuf, readAmount));
|
|
||||||
if (actual != (ssize_t) readAmount) {
|
|
||||||
ALOGW("Zip: read " ZD ", expected " ZD ". Failed: %s\n",
|
|
||||||
(ZD_TYPE) actual, (ZD_TYPE) readAmount, strerror(errno));
|
|
||||||
free(scanBuf);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Scan backward for the EOCD magic. In an archive without a trailing
|
|
||||||
* comment, we'll find it on the first try. (We may want to consider
|
|
||||||
* doing an initial minimal read; if we don't find it, retry with a
|
|
||||||
* second read as above.)
|
|
||||||
*/
|
|
||||||
int i;
|
|
||||||
for (i = readAmount - kEOCDLen; i >= 0; i--) {
|
|
||||||
if (scanBuf[i] == 0x50 && get4LE(&scanBuf[i]) == kEOCDSignature) {
|
|
||||||
ALOGV("+++ Found EOCD at buf+%d\n", i);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (i < 0) {
|
|
||||||
ALOGD("Zip: EOCD not found, %s is not zip\n", mFileName);
|
|
||||||
free(scanBuf);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
off64_t eocdOffset = searchStart + i;
|
|
||||||
const unsigned char* eocdPtr = scanBuf + i;
|
|
||||||
|
|
||||||
assert(eocdOffset < mFileLength);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Grab the CD offset and size, and the number of entries in the
|
|
||||||
* archive. After that, we can release our EOCD hunt buffer.
|
|
||||||
*/
|
|
||||||
unsigned int numEntries = get2LE(eocdPtr + kEOCDNumEntries);
|
|
||||||
unsigned int dirSize = get4LE(eocdPtr + kEOCDSize);
|
|
||||||
unsigned int dirOffset = get4LE(eocdPtr + kEOCDFileOffset);
|
|
||||||
free(scanBuf);
|
|
||||||
|
|
||||||
// Verify that they look reasonable.
|
|
||||||
if ((long long) dirOffset + (long long) dirSize > (long long) eocdOffset) {
|
|
||||||
ALOGW("bad offsets (dir %ld, size %u, eocd %ld)\n",
|
|
||||||
(long) dirOffset, dirSize, (long) eocdOffset);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
if (numEntries == 0) {
|
|
||||||
ALOGW("empty archive?\n");
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
ALOGV("+++ numEntries=%d dirSize=%d dirOffset=%d\n",
|
|
||||||
numEntries, dirSize, dirOffset);
|
|
||||||
|
|
||||||
mDirectoryMap = new FileMap();
|
|
||||||
if (mDirectoryMap == NULL) {
|
|
||||||
ALOGW("Unable to create directory map: %s", strerror(errno));
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!mDirectoryMap->create(mFileName, mFd, dirOffset, dirSize, true)) {
|
|
||||||
ALOGW("Unable to map '%s' (" ZD " to " ZD "): %s\n", mFileName,
|
|
||||||
(ZD_TYPE) dirOffset, (ZD_TYPE) (dirOffset + dirSize), strerror(errno));
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
mNumEntries = numEntries;
|
|
||||||
mDirectoryOffset = dirOffset;
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Round up to the next highest power of 2.
|
|
||||||
*
|
|
||||||
* Found on http://graphics.stanford.edu/~seander/bithacks.html.
|
|
||||||
*/
|
|
||||||
static unsigned int roundUpPower2(unsigned int val)
|
|
||||||
{
|
|
||||||
val--;
|
|
||||||
val |= val >> 1;
|
|
||||||
val |= val >> 2;
|
|
||||||
val |= val >> 4;
|
|
||||||
val |= val >> 8;
|
|
||||||
val |= val >> 16;
|
|
||||||
val++;
|
|
||||||
|
|
||||||
return val;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ZipFileRO::parseZipArchive(void)
|
|
||||||
{
|
|
||||||
bool result = false;
|
|
||||||
const unsigned char* cdPtr = (const unsigned char*) mDirectoryMap->getDataPtr();
|
|
||||||
size_t cdLength = mDirectoryMap->getDataLength();
|
|
||||||
int numEntries = mNumEntries;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Create hash table. We have a minimum 75% load factor, possibly as
|
|
||||||
* low as 50% after we round off to a power of 2.
|
|
||||||
*/
|
|
||||||
mHashTableSize = roundUpPower2(1 + (numEntries * 4) / 3);
|
|
||||||
mHashTable = (HashEntry*) calloc(mHashTableSize, sizeof(HashEntry));
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Walk through the central directory, adding entries to the hash
|
|
||||||
* table.
|
|
||||||
*/
|
|
||||||
const unsigned char* ptr = cdPtr;
|
|
||||||
for (int i = 0; i < numEntries; i++) {
|
|
||||||
if (get4LE(ptr) != kCDESignature) {
|
|
||||||
ALOGW("Missed a central dir sig (at %d)\n", i);
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
if (ptr + kCDELen > cdPtr + cdLength) {
|
|
||||||
ALOGW("Ran off the end (at %d)\n", i);
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
long localHdrOffset = (long) get4LE(ptr + kCDELocalOffset);
|
|
||||||
if (localHdrOffset >= mDirectoryOffset) {
|
|
||||||
ALOGW("bad LFH offset %ld at entry %d\n", localHdrOffset, i);
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int fileNameLen, extraLen, commentLen, hash;
|
|
||||||
|
|
||||||
fileNameLen = get2LE(ptr + kCDENameLen);
|
|
||||||
extraLen = get2LE(ptr + kCDEExtraLen);
|
|
||||||
commentLen = get2LE(ptr + kCDECommentLen);
|
|
||||||
|
|
||||||
/* add the CDE filename to the hash table */
|
|
||||||
hash = computeHash((const char*)ptr + kCDELen, fileNameLen);
|
|
||||||
addToHash((const char*)ptr + kCDELen, fileNameLen, hash);
|
|
||||||
|
|
||||||
ptr += kCDELen + fileNameLen + extraLen + commentLen;
|
|
||||||
if ((size_t)(ptr - cdPtr) > cdLength) {
|
|
||||||
ALOGW("bad CD advance (%d vs " ZD ") at entry %d\n",
|
|
||||||
(int) (ptr - cdPtr), (ZD_TYPE) cdLength, i);
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
ALOGV("+++ zip good scan %d entries\n", numEntries);
|
|
||||||
result = true;
|
|
||||||
|
|
||||||
bail:
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Simple string hash function for non-null-terminated strings.
|
|
||||||
*/
|
|
||||||
/*static*/ unsigned int ZipFileRO::computeHash(const char* str, int len)
|
|
||||||
{
|
|
||||||
unsigned int hash = 0;
|
|
||||||
|
|
||||||
while (len--)
|
|
||||||
hash = hash * 31 + *str++;
|
|
||||||
|
|
||||||
return hash;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Add a new entry to the hash table.
|
|
||||||
*/
|
|
||||||
void ZipFileRO::addToHash(const char* str, int strLen, unsigned int hash)
|
|
||||||
{
|
|
||||||
int ent = hash & (mHashTableSize-1);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* We over-allocate the table, so we're guaranteed to find an empty slot.
|
|
||||||
*/
|
|
||||||
while (mHashTable[ent].name != NULL)
|
|
||||||
ent = (ent + 1) & (mHashTableSize-1);
|
|
||||||
|
|
||||||
mHashTable[ent].name = str;
|
|
||||||
mHashTable[ent].nameLen = strLen;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Find a matching entry.
|
|
||||||
*
|
|
||||||
* Returns NULL if not found.
|
|
||||||
*/
|
|
||||||
ZipEntryRO ZipFileRO::findEntryByName(const char* fileName) const
|
|
||||||
{
|
|
||||||
/*
|
|
||||||
* If the ZipFileRO instance is not initialized, the entry number will
|
|
||||||
* end up being garbage since mHashTableSize is -1.
|
|
||||||
*/
|
|
||||||
if (mHashTableSize <= 0) {
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
int nameLen = strlen(fileName);
|
|
||||||
unsigned int hash = computeHash(fileName, nameLen);
|
|
||||||
int ent = hash & (mHashTableSize-1);
|
|
||||||
|
|
||||||
while (mHashTable[ent].name != NULL) {
|
|
||||||
if (mHashTable[ent].nameLen == nameLen &&
|
|
||||||
memcmp(mHashTable[ent].name, fileName, nameLen) == 0)
|
|
||||||
{
|
|
||||||
/* match */
|
|
||||||
return (ZipEntryRO)(long)(ent + kZipEntryAdj);
|
|
||||||
}
|
|
||||||
|
|
||||||
ent = (ent + 1) & (mHashTableSize-1);
|
|
||||||
}
|
|
||||||
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Find the Nth entry.
|
|
||||||
*
|
|
||||||
* This currently involves walking through the sparse hash table, counting
|
|
||||||
* non-empty entries. If we need to speed this up we can either allocate
|
|
||||||
* a parallel lookup table or (perhaps better) provide an iterator interface.
|
|
||||||
*/
|
|
||||||
ZipEntryRO ZipFileRO::findEntryByIndex(int idx) const
|
|
||||||
{
|
|
||||||
if (idx < 0 || idx >= mNumEntries) {
|
|
||||||
ALOGW("Invalid index %d\n", idx);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (int ent = 0; ent < mHashTableSize; ent++) {
|
|
||||||
if (mHashTable[ent].name != NULL) {
|
|
||||||
if (idx-- == 0)
|
|
||||||
return (ZipEntryRO) (intptr_t)(ent + kZipEntryAdj);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the useful fields from the zip entry.
|
|
||||||
*
|
|
||||||
* Returns "false" if the offsets to the fields or the contents of the fields
|
|
||||||
* appear to be bogus.
|
|
||||||
*/
|
|
||||||
bool ZipFileRO::getEntryInfo(ZipEntryRO entry, int* pMethod, size_t* pUncompLen,
|
|
||||||
size_t* pCompLen, off64_t* pOffset, long* pModWhen, long* pCrc32) const
|
|
||||||
{
|
|
||||||
bool ret = false;
|
|
||||||
|
|
||||||
const int ent = entryToIndex(entry);
|
|
||||||
if (ent < 0)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
HashEntry hashEntry = mHashTable[ent];
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Recover the start of the central directory entry from the filename
|
|
||||||
* pointer. The filename is the first entry past the fixed-size data,
|
|
||||||
* so we can just subtract back from that.
|
|
||||||
*/
|
|
||||||
const unsigned char* ptr = (const unsigned char*) hashEntry.name;
|
|
||||||
off64_t cdOffset = mDirectoryOffset;
|
|
||||||
|
|
||||||
ptr -= kCDELen;
|
|
||||||
|
|
||||||
int method = get2LE(ptr + kCDEMethod);
|
|
||||||
if (pMethod != NULL)
|
|
||||||
*pMethod = method;
|
|
||||||
|
|
||||||
if (pModWhen != NULL)
|
|
||||||
*pModWhen = get4LE(ptr + kCDEModWhen);
|
|
||||||
if (pCrc32 != NULL)
|
|
||||||
*pCrc32 = get4LE(ptr + kCDECRC);
|
|
||||||
|
|
||||||
size_t compLen = get4LE(ptr + kCDECompLen);
|
|
||||||
if (pCompLen != NULL)
|
|
||||||
*pCompLen = compLen;
|
|
||||||
size_t uncompLen = get4LE(ptr + kCDEUncompLen);
|
|
||||||
if (pUncompLen != NULL)
|
|
||||||
*pUncompLen = uncompLen;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If requested, determine the offset of the start of the data. All we
|
|
||||||
* have is the offset to the Local File Header, which is variable size,
|
|
||||||
* so we have to read the contents of the struct to figure out where
|
|
||||||
* the actual data starts.
|
|
||||||
*
|
|
||||||
* We also need to make sure that the lengths are not so large that
|
|
||||||
* somebody trying to map the compressed or uncompressed data runs
|
|
||||||
* off the end of the mapped region.
|
|
||||||
*
|
|
||||||
* Note we don't verify compLen/uncompLen if they don't request the
|
|
||||||
* dataOffset, because dataOffset is expensive to determine. However,
|
|
||||||
* if they don't have the file offset, they're not likely to be doing
|
|
||||||
* anything with the contents.
|
|
||||||
*/
|
|
||||||
if (pOffset != NULL) {
|
|
||||||
long localHdrOffset = get4LE(ptr + kCDELocalOffset);
|
|
||||||
if (localHdrOffset + kLFHLen >= cdOffset) {
|
|
||||||
ALOGE("ERROR: bad local hdr offset in zip\n");
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned char lfhBuf[kLFHLen];
|
|
||||||
|
|
||||||
#ifdef HAVE_PREAD
|
|
||||||
/*
|
|
||||||
* This file descriptor might be from zygote's preloaded assets,
|
|
||||||
* so we need to do an pread64() instead of a lseek64() + read() to
|
|
||||||
* guarantee atomicity across the processes with the shared file
|
|
||||||
* descriptors.
|
|
||||||
*/
|
|
||||||
ssize_t actual =
|
|
||||||
TEMP_FAILURE_RETRY(pread64(mFd, lfhBuf, sizeof(lfhBuf), localHdrOffset));
|
|
||||||
|
|
||||||
if (actual != sizeof(lfhBuf)) {
|
|
||||||
ALOGW("failed reading lfh from offset %ld\n", localHdrOffset);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (get4LE(lfhBuf) != kLFHSignature) {
|
|
||||||
ALOGW("didn't find signature at start of lfh; wanted: offset=%ld data=0x%08x; "
|
|
||||||
"got: data=0x%08lx\n",
|
|
||||||
localHdrOffset, kLFHSignature, get4LE(lfhBuf));
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
#else /* HAVE_PREAD */
|
|
||||||
/*
|
|
||||||
* For hosts don't have pread64() we cannot guarantee atomic reads from
|
|
||||||
* an offset in a file. Android should never run on those platforms.
|
|
||||||
* File descriptors inherited from a fork() share file offsets and
|
|
||||||
* there would be nothing to protect from two different processes
|
|
||||||
* calling lseek64() concurrently.
|
|
||||||
*/
|
|
||||||
|
|
||||||
{
|
|
||||||
AutoMutex _l(mFdLock);
|
|
||||||
|
|
||||||
if (lseek64(mFd, localHdrOffset, SEEK_SET) != localHdrOffset) {
|
|
||||||
ALOGW("failed seeking to lfh at offset %ld\n", localHdrOffset);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t actual =
|
|
||||||
TEMP_FAILURE_RETRY(read(mFd, lfhBuf, sizeof(lfhBuf)));
|
|
||||||
if (actual != sizeof(lfhBuf)) {
|
|
||||||
ALOGW("failed reading lfh from offset %ld\n", localHdrOffset);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (get4LE(lfhBuf) != kLFHSignature) {
|
|
||||||
off64_t actualOffset = lseek64(mFd, 0, SEEK_CUR);
|
|
||||||
ALOGW("didn't find signature at start of lfh; wanted: offset=%ld data=0x%08x; "
|
|
||||||
"got: offset=" ZD " data=0x%08lx\n",
|
|
||||||
localHdrOffset, kLFHSignature, (ZD_TYPE) actualOffset, get4LE(lfhBuf));
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif /* HAVE_PREAD */
|
|
||||||
|
|
||||||
off64_t dataOffset = localHdrOffset + kLFHLen
|
|
||||||
+ get2LE(lfhBuf + kLFHNameLen) + get2LE(lfhBuf + kLFHExtraLen);
|
|
||||||
if (dataOffset >= cdOffset) {
|
|
||||||
ALOGW("bad data offset %ld in zip\n", (long) dataOffset);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* check lengths */
|
|
||||||
if ((off64_t)(dataOffset + compLen) > cdOffset) {
|
|
||||||
ALOGW("bad compressed length in zip (%ld + " ZD " > %ld)\n",
|
|
||||||
(long) dataOffset, (ZD_TYPE) compLen, (long) cdOffset);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (method == kCompressStored &&
|
|
||||||
(off64_t)(dataOffset + uncompLen) > cdOffset)
|
|
||||||
{
|
|
||||||
ALOGE("ERROR: bad uncompressed length in zip (%ld + " ZD " > %ld)\n",
|
|
||||||
(long) dataOffset, (ZD_TYPE) uncompLen, (long) cdOffset);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
*pOffset = dataOffset;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Copy the entry's filename to the buffer.
|
|
||||||
*/
|
|
||||||
int ZipFileRO::getEntryFileName(ZipEntryRO entry, char* buffer, int bufLen)
|
|
||||||
const
|
|
||||||
{
|
|
||||||
int ent = entryToIndex(entry);
|
|
||||||
if (ent < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
int nameLen = mHashTable[ent].nameLen;
|
|
||||||
if (bufLen < nameLen+1)
|
|
||||||
return nameLen+1;
|
|
||||||
|
|
||||||
memcpy(buffer, mHashTable[ent].name, nameLen);
|
|
||||||
buffer[nameLen] = '\0';
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Create a new FileMap object that spans the data in "entry".
|
|
||||||
*/
|
|
||||||
FileMap* ZipFileRO::createEntryFileMap(ZipEntryRO entry) const
|
|
||||||
{
|
|
||||||
/*
|
|
||||||
* TODO: the efficient way to do this is to modify FileMap to allow
|
|
||||||
* sub-regions of a file to be mapped. A reference-counting scheme
|
|
||||||
* can manage the base memory mapping. For now, we just create a brand
|
|
||||||
* new mapping off of the Zip archive file descriptor.
|
|
||||||
*/
|
|
||||||
|
|
||||||
FileMap* newMap;
|
|
||||||
size_t compLen;
|
|
||||||
off64_t offset;
|
|
||||||
|
|
||||||
if (!getEntryInfo(entry, NULL, NULL, &compLen, &offset, NULL, NULL))
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
newMap = new FileMap();
|
|
||||||
if (!newMap->create(mFileName, mFd, offset, compLen, true)) {
|
|
||||||
newMap->release();
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
return newMap;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Uncompress an entry, in its entirety, into the provided output buffer.
|
|
||||||
*
|
|
||||||
* This doesn't verify the data's CRC, which might be useful for
|
|
||||||
* uncompressed data. The caller should be able to manage it.
|
|
||||||
*/
|
|
||||||
bool ZipFileRO::uncompressEntry(ZipEntryRO entry, void* buffer) const
|
|
||||||
{
|
|
||||||
const size_t kSequentialMin = 32768;
|
|
||||||
bool result = false;
|
|
||||||
int ent = entryToIndex(entry);
|
|
||||||
if (ent < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
int method;
|
|
||||||
size_t uncompLen, compLen;
|
|
||||||
off64_t offset;
|
|
||||||
const unsigned char* ptr;
|
|
||||||
|
|
||||||
getEntryInfo(entry, &method, &uncompLen, &compLen, &offset, NULL, NULL);
|
|
||||||
|
|
||||||
FileMap* file = createEntryFileMap(entry);
|
|
||||||
if (file == NULL) {
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
ptr = (const unsigned char*) file->getDataPtr();
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Experiment with madvise hint. When we want to uncompress a file,
|
|
||||||
* we pull some stuff out of the central dir entry and then hit a
|
|
||||||
* bunch of compressed or uncompressed data sequentially. The CDE
|
|
||||||
* visit will cause a limited amount of read-ahead because it's at
|
|
||||||
* the end of the file. We could end up doing lots of extra disk
|
|
||||||
* access if the file we're prying open is small. Bottom line is we
|
|
||||||
* probably don't want to turn MADV_SEQUENTIAL on and leave it on.
|
|
||||||
*
|
|
||||||
* So, if the compressed size of the file is above a certain minimum
|
|
||||||
* size, temporarily boost the read-ahead in the hope that the extra
|
|
||||||
* pair of system calls are negated by a reduction in page faults.
|
|
||||||
*/
|
|
||||||
if (compLen > kSequentialMin)
|
|
||||||
file->advise(FileMap::SEQUENTIAL);
|
|
||||||
|
|
||||||
if (method == kCompressStored) {
|
|
||||||
memcpy(buffer, ptr, uncompLen);
|
|
||||||
} else {
|
|
||||||
if (!inflateBuffer(buffer, ptr, uncompLen, compLen))
|
|
||||||
goto unmap;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (compLen > kSequentialMin)
|
|
||||||
file->advise(FileMap::NORMAL);
|
|
||||||
|
|
||||||
result = true;
|
|
||||||
|
|
||||||
unmap:
|
|
||||||
file->release();
|
|
||||||
bail:
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Uncompress an entry, in its entirety, to an open file descriptor.
|
|
||||||
*
|
|
||||||
* This doesn't verify the data's CRC, but probably should.
|
|
||||||
*/
|
|
||||||
bool ZipFileRO::uncompressEntry(ZipEntryRO entry, int fd) const
|
|
||||||
{
|
|
||||||
bool result = false;
|
|
||||||
int ent = entryToIndex(entry);
|
|
||||||
if (ent < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
int method;
|
|
||||||
size_t uncompLen, compLen;
|
|
||||||
off64_t offset;
|
|
||||||
const unsigned char* ptr;
|
|
||||||
|
|
||||||
getEntryInfo(entry, &method, &uncompLen, &compLen, &offset, NULL, NULL);
|
|
||||||
|
|
||||||
FileMap* file = createEntryFileMap(entry);
|
|
||||||
if (file == NULL) {
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
ptr = (const unsigned char*) file->getDataPtr();
|
|
||||||
|
|
||||||
if (method == kCompressStored) {
|
|
||||||
ssize_t actual = TEMP_FAILURE_RETRY(write(fd, ptr, uncompLen));
|
|
||||||
if (actual < 0) {
|
|
||||||
ALOGE("Write failed: %s\n", strerror(errno));
|
|
||||||
goto unmap;
|
|
||||||
} else if ((size_t) actual != uncompLen) {
|
|
||||||
ALOGE("Partial write during uncompress (" ZD " of " ZD ")\n",
|
|
||||||
(ZD_TYPE) actual, (ZD_TYPE) uncompLen);
|
|
||||||
goto unmap;
|
|
||||||
} else {
|
|
||||||
ALOGI("+++ successful write\n");
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if (!inflateBuffer(fd, ptr, uncompLen, compLen))
|
|
||||||
goto unmap;
|
|
||||||
}
|
|
||||||
|
|
||||||
result = true;
|
|
||||||
|
|
||||||
unmap:
|
|
||||||
file->release();
|
|
||||||
bail:
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Uncompress "deflate" data from one buffer to another.
|
|
||||||
*/
|
|
||||||
/*static*/ bool ZipFileRO::inflateBuffer(void* outBuf, const void* inBuf,
|
|
||||||
size_t uncompLen, size_t compLen)
|
|
||||||
{
|
|
||||||
bool result = false;
|
|
||||||
z_stream zstream;
|
|
||||||
int zerr;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Initialize the zlib stream struct.
|
|
||||||
*/
|
|
||||||
memset(&zstream, 0, sizeof(zstream));
|
|
||||||
zstream.zalloc = Z_NULL;
|
|
||||||
zstream.zfree = Z_NULL;
|
|
||||||
zstream.opaque = Z_NULL;
|
|
||||||
zstream.next_in = (Bytef*)inBuf;
|
|
||||||
zstream.avail_in = compLen;
|
|
||||||
zstream.next_out = (Bytef*) outBuf;
|
|
||||||
zstream.avail_out = uncompLen;
|
|
||||||
zstream.data_type = Z_UNKNOWN;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Use the undocumented "negative window bits" feature to tell zlib
|
|
||||||
* that there's no zlib header waiting for it.
|
|
||||||
*/
|
|
||||||
zerr = inflateInit2(&zstream, -MAX_WBITS);
|
|
||||||
if (zerr != Z_OK) {
|
|
||||||
if (zerr == Z_VERSION_ERROR) {
|
|
||||||
ALOGE("Installed zlib is not compatible with linked version (%s)\n",
|
|
||||||
ZLIB_VERSION);
|
|
||||||
} else {
|
|
||||||
ALOGE("Call to inflateInit2 failed (zerr=%d)\n", zerr);
|
|
||||||
}
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Expand data.
|
|
||||||
*/
|
|
||||||
zerr = inflate(&zstream, Z_FINISH);
|
|
||||||
if (zerr != Z_STREAM_END) {
|
|
||||||
ALOGW("Zip inflate failed, zerr=%d (nIn=%p aIn=%u nOut=%p aOut=%u)\n",
|
|
||||||
zerr, zstream.next_in, zstream.avail_in,
|
|
||||||
zstream.next_out, zstream.avail_out);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* paranoia */
|
|
||||||
if (zstream.total_out != uncompLen) {
|
|
||||||
ALOGW("Size mismatch on inflated file (%ld vs " ZD ")\n",
|
|
||||||
zstream.total_out, (ZD_TYPE) uncompLen);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
result = true;
|
|
||||||
|
|
||||||
z_bail:
|
|
||||||
inflateEnd(&zstream); /* free up any allocated structures */
|
|
||||||
|
|
||||||
bail:
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Uncompress "deflate" data from one buffer to an open file descriptor.
|
|
||||||
*/
|
|
||||||
/*static*/ bool ZipFileRO::inflateBuffer(int fd, const void* inBuf,
|
|
||||||
size_t uncompLen, size_t compLen)
|
|
||||||
{
|
|
||||||
bool result = false;
|
|
||||||
const size_t kWriteBufSize = 32768;
|
|
||||||
unsigned char writeBuf[kWriteBufSize];
|
|
||||||
z_stream zstream;
|
|
||||||
int zerr;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Initialize the zlib stream struct.
|
|
||||||
*/
|
|
||||||
memset(&zstream, 0, sizeof(zstream));
|
|
||||||
zstream.zalloc = Z_NULL;
|
|
||||||
zstream.zfree = Z_NULL;
|
|
||||||
zstream.opaque = Z_NULL;
|
|
||||||
zstream.next_in = (Bytef*)inBuf;
|
|
||||||
zstream.avail_in = compLen;
|
|
||||||
zstream.next_out = (Bytef*) writeBuf;
|
|
||||||
zstream.avail_out = sizeof(writeBuf);
|
|
||||||
zstream.data_type = Z_UNKNOWN;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Use the undocumented "negative window bits" feature to tell zlib
|
|
||||||
* that there's no zlib header waiting for it.
|
|
||||||
*/
|
|
||||||
zerr = inflateInit2(&zstream, -MAX_WBITS);
|
|
||||||
if (zerr != Z_OK) {
|
|
||||||
if (zerr == Z_VERSION_ERROR) {
|
|
||||||
ALOGE("Installed zlib is not compatible with linked version (%s)\n",
|
|
||||||
ZLIB_VERSION);
|
|
||||||
} else {
|
|
||||||
ALOGE("Call to inflateInit2 failed (zerr=%d)\n", zerr);
|
|
||||||
}
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Loop while we have more to do.
|
|
||||||
*/
|
|
||||||
do {
|
|
||||||
/*
|
|
||||||
* Expand data.
|
|
||||||
*/
|
|
||||||
zerr = inflate(&zstream, Z_NO_FLUSH);
|
|
||||||
if (zerr != Z_OK && zerr != Z_STREAM_END) {
|
|
||||||
ALOGW("zlib inflate: zerr=%d (nIn=%p aIn=%u nOut=%p aOut=%u)\n",
|
|
||||||
zerr, zstream.next_in, zstream.avail_in,
|
|
||||||
zstream.next_out, zstream.avail_out);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* write when we're full or when we're done */
|
|
||||||
if (zstream.avail_out == 0 ||
|
|
||||||
(zerr == Z_STREAM_END && zstream.avail_out != sizeof(writeBuf)))
|
|
||||||
{
|
|
||||||
long writeSize = zstream.next_out - writeBuf;
|
|
||||||
int cc = TEMP_FAILURE_RETRY(write(fd, writeBuf, writeSize));
|
|
||||||
if (cc < 0) {
|
|
||||||
ALOGW("write failed in inflate: %s", strerror(errno));
|
|
||||||
goto z_bail;
|
|
||||||
} else if (cc != (int) writeSize) {
|
|
||||||
ALOGW("write failed in inflate (%d vs %ld)", cc, writeSize);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
zstream.next_out = writeBuf;
|
|
||||||
zstream.avail_out = sizeof(writeBuf);
|
|
||||||
}
|
|
||||||
} while (zerr == Z_OK);
|
|
||||||
|
|
||||||
assert(zerr == Z_STREAM_END); /* other errors should've been caught */
|
|
||||||
|
|
||||||
/* paranoia */
|
|
||||||
if (zstream.total_out != uncompLen) {
|
|
||||||
ALOGW("Size mismatch on inflated file (%ld vs " ZD ")\n",
|
|
||||||
zstream.total_out, (ZD_TYPE) uncompLen);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
result = true;
|
|
||||||
|
|
||||||
z_bail:
|
|
||||||
inflateEnd(&zstream); /* free up any allocated structures */
|
|
||||||
|
|
||||||
bail:
|
|
||||||
return result;
|
|
||||||
}
|
|
|
@ -1,345 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 2007 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
//
|
|
||||||
// Misc zip/gzip utility functions.
|
|
||||||
//
|
|
||||||
|
|
||||||
#define LOG_TAG "ziputil"
|
|
||||||
|
|
||||||
#include <utils/Log.h>
|
|
||||||
#include <utils/Compat.h>
|
|
||||||
#include <utils/ZipUtils.h>
|
|
||||||
#include <utils/ZipFileRO.h>
|
|
||||||
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include <assert.h>
|
|
||||||
|
|
||||||
#include <zlib.h>
|
|
||||||
|
|
||||||
using namespace android;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Utility function that expands zip/gzip "deflate" compressed data
|
|
||||||
* into a buffer.
|
|
||||||
*
|
|
||||||
* "fd" is an open file positioned at the start of the "deflate" data
|
|
||||||
* "buf" must hold at least "uncompressedLen" bytes.
|
|
||||||
*/
|
|
||||||
/*static*/ bool ZipUtils::inflateToBuffer(int fd, void* buf,
|
|
||||||
long uncompressedLen, long compressedLen)
|
|
||||||
{
|
|
||||||
bool result = false;
|
|
||||||
const unsigned long kReadBufSize = 32768;
|
|
||||||
unsigned char* readBuf = NULL;
|
|
||||||
z_stream zstream;
|
|
||||||
int zerr;
|
|
||||||
unsigned long compRemaining;
|
|
||||||
|
|
||||||
assert(uncompressedLen >= 0);
|
|
||||||
assert(compressedLen >= 0);
|
|
||||||
|
|
||||||
readBuf = new unsigned char[kReadBufSize];
|
|
||||||
if (readBuf == NULL)
|
|
||||||
goto bail;
|
|
||||||
compRemaining = compressedLen;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Initialize the zlib stream.
|
|
||||||
*/
|
|
||||||
memset(&zstream, 0, sizeof(zstream));
|
|
||||||
zstream.zalloc = Z_NULL;
|
|
||||||
zstream.zfree = Z_NULL;
|
|
||||||
zstream.opaque = Z_NULL;
|
|
||||||
zstream.next_in = NULL;
|
|
||||||
zstream.avail_in = 0;
|
|
||||||
zstream.next_out = (Bytef*) buf;
|
|
||||||
zstream.avail_out = uncompressedLen;
|
|
||||||
zstream.data_type = Z_UNKNOWN;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Use the undocumented "negative window bits" feature to tell zlib
|
|
||||||
* that there's no zlib header waiting for it.
|
|
||||||
*/
|
|
||||||
zerr = inflateInit2(&zstream, -MAX_WBITS);
|
|
||||||
if (zerr != Z_OK) {
|
|
||||||
if (zerr == Z_VERSION_ERROR) {
|
|
||||||
ALOGE("Installed zlib is not compatible with linked version (%s)\n",
|
|
||||||
ZLIB_VERSION);
|
|
||||||
} else {
|
|
||||||
ALOGE("Call to inflateInit2 failed (zerr=%d)\n", zerr);
|
|
||||||
}
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Loop while we have data.
|
|
||||||
*/
|
|
||||||
do {
|
|
||||||
unsigned long getSize;
|
|
||||||
|
|
||||||
/* read as much as we can */
|
|
||||||
if (zstream.avail_in == 0) {
|
|
||||||
getSize = (compRemaining > kReadBufSize) ?
|
|
||||||
kReadBufSize : compRemaining;
|
|
||||||
ALOGV("+++ reading %ld bytes (%ld left)\n",
|
|
||||||
getSize, compRemaining);
|
|
||||||
|
|
||||||
int cc = TEMP_FAILURE_RETRY(read(fd, readBuf, getSize));
|
|
||||||
if (cc < 0) {
|
|
||||||
ALOGW("inflate read failed: %s", strerror(errno));
|
|
||||||
} else if (cc != (int) getSize) {
|
|
||||||
ALOGW("inflate read failed (%d vs %ld)", cc, getSize);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
compRemaining -= getSize;
|
|
||||||
|
|
||||||
zstream.next_in = readBuf;
|
|
||||||
zstream.avail_in = getSize;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* uncompress the data */
|
|
||||||
zerr = inflate(&zstream, Z_NO_FLUSH);
|
|
||||||
if (zerr != Z_OK && zerr != Z_STREAM_END) {
|
|
||||||
ALOGD("zlib inflate call failed (zerr=%d)\n", zerr);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* output buffer holds all, so no need to write the output */
|
|
||||||
} while (zerr == Z_OK);
|
|
||||||
|
|
||||||
assert(zerr == Z_STREAM_END); /* other errors should've been caught */
|
|
||||||
|
|
||||||
if ((long) zstream.total_out != uncompressedLen) {
|
|
||||||
ALOGW("Size mismatch on inflated file (%ld vs %ld)\n",
|
|
||||||
zstream.total_out, uncompressedLen);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
// success!
|
|
||||||
result = true;
|
|
||||||
|
|
||||||
z_bail:
|
|
||||||
inflateEnd(&zstream); /* free up any allocated structures */
|
|
||||||
|
|
||||||
bail:
|
|
||||||
delete[] readBuf;
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Utility function that expands zip/gzip "deflate" compressed data
|
|
||||||
* into a buffer.
|
|
||||||
*
|
|
||||||
* (This is a clone of the previous function, but it takes a FILE* instead
|
|
||||||
* of an fd. We could pass fileno(fd) to the above, but we can run into
|
|
||||||
* trouble when "fp" has a different notion of what fd's file position is.)
|
|
||||||
*
|
|
||||||
* "fp" is an open file positioned at the start of the "deflate" data
|
|
||||||
* "buf" must hold at least "uncompressedLen" bytes.
|
|
||||||
*/
|
|
||||||
/*static*/ bool ZipUtils::inflateToBuffer(FILE* fp, void* buf,
|
|
||||||
long uncompressedLen, long compressedLen)
|
|
||||||
{
|
|
||||||
bool result = false;
|
|
||||||
const unsigned long kReadBufSize = 32768;
|
|
||||||
unsigned char* readBuf = NULL;
|
|
||||||
z_stream zstream;
|
|
||||||
int zerr;
|
|
||||||
unsigned long compRemaining;
|
|
||||||
|
|
||||||
assert(uncompressedLen >= 0);
|
|
||||||
assert(compressedLen >= 0);
|
|
||||||
|
|
||||||
readBuf = new unsigned char[kReadBufSize];
|
|
||||||
if (readBuf == NULL)
|
|
||||||
goto bail;
|
|
||||||
compRemaining = compressedLen;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Initialize the zlib stream.
|
|
||||||
*/
|
|
||||||
memset(&zstream, 0, sizeof(zstream));
|
|
||||||
zstream.zalloc = Z_NULL;
|
|
||||||
zstream.zfree = Z_NULL;
|
|
||||||
zstream.opaque = Z_NULL;
|
|
||||||
zstream.next_in = NULL;
|
|
||||||
zstream.avail_in = 0;
|
|
||||||
zstream.next_out = (Bytef*) buf;
|
|
||||||
zstream.avail_out = uncompressedLen;
|
|
||||||
zstream.data_type = Z_UNKNOWN;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Use the undocumented "negative window bits" feature to tell zlib
|
|
||||||
* that there's no zlib header waiting for it.
|
|
||||||
*/
|
|
||||||
zerr = inflateInit2(&zstream, -MAX_WBITS);
|
|
||||||
if (zerr != Z_OK) {
|
|
||||||
if (zerr == Z_VERSION_ERROR) {
|
|
||||||
ALOGE("Installed zlib is not compatible with linked version (%s)\n",
|
|
||||||
ZLIB_VERSION);
|
|
||||||
} else {
|
|
||||||
ALOGE("Call to inflateInit2 failed (zerr=%d)\n", zerr);
|
|
||||||
}
|
|
||||||
goto bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Loop while we have data.
|
|
||||||
*/
|
|
||||||
do {
|
|
||||||
unsigned long getSize;
|
|
||||||
|
|
||||||
/* read as much as we can */
|
|
||||||
if (zstream.avail_in == 0) {
|
|
||||||
getSize = (compRemaining > kReadBufSize) ?
|
|
||||||
kReadBufSize : compRemaining;
|
|
||||||
ALOGV("+++ reading %ld bytes (%ld left)\n",
|
|
||||||
getSize, compRemaining);
|
|
||||||
|
|
||||||
int cc = fread(readBuf, 1, getSize, fp);
|
|
||||||
if (cc != (int) getSize) {
|
|
||||||
ALOGD("inflate read failed (%d vs %ld)\n",
|
|
||||||
cc, getSize);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
compRemaining -= getSize;
|
|
||||||
|
|
||||||
zstream.next_in = readBuf;
|
|
||||||
zstream.avail_in = getSize;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* uncompress the data */
|
|
||||||
zerr = inflate(&zstream, Z_NO_FLUSH);
|
|
||||||
if (zerr != Z_OK && zerr != Z_STREAM_END) {
|
|
||||||
ALOGD("zlib inflate call failed (zerr=%d)\n", zerr);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* output buffer holds all, so no need to write the output */
|
|
||||||
} while (zerr == Z_OK);
|
|
||||||
|
|
||||||
assert(zerr == Z_STREAM_END); /* other errors should've been caught */
|
|
||||||
|
|
||||||
if ((long) zstream.total_out != uncompressedLen) {
|
|
||||||
ALOGW("Size mismatch on inflated file (%ld vs %ld)\n",
|
|
||||||
zstream.total_out, uncompressedLen);
|
|
||||||
goto z_bail;
|
|
||||||
}
|
|
||||||
|
|
||||||
// success!
|
|
||||||
result = true;
|
|
||||||
|
|
||||||
z_bail:
|
|
||||||
inflateEnd(&zstream); /* free up any allocated structures */
|
|
||||||
|
|
||||||
bail:
|
|
||||||
delete[] readBuf;
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Look at the contents of a gzip archive. We want to know where the
|
|
||||||
* data starts, and how long it will be after it is uncompressed.
|
|
||||||
*
|
|
||||||
* We expect to find the CRC and length as the last 8 bytes on the file.
|
|
||||||
* This is a pretty reasonable thing to expect for locally-compressed
|
|
||||||
* files, but there's a small chance that some extra padding got thrown
|
|
||||||
* on (the man page talks about compressed data written to tape). We
|
|
||||||
* don't currently deal with that here. If "gzip -l" whines, we're going
|
|
||||||
* to fail too.
|
|
||||||
*
|
|
||||||
* On exit, "fp" is pointing at the start of the compressed data.
|
|
||||||
*/
|
|
||||||
/*static*/ bool ZipUtils::examineGzip(FILE* fp, int* pCompressionMethod,
|
|
||||||
long* pUncompressedLen, long* pCompressedLen, unsigned long* pCRC32)
|
|
||||||
{
|
|
||||||
enum { // flags
|
|
||||||
FTEXT = 0x01,
|
|
||||||
FHCRC = 0x02,
|
|
||||||
FEXTRA = 0x04,
|
|
||||||
FNAME = 0x08,
|
|
||||||
FCOMMENT = 0x10,
|
|
||||||
};
|
|
||||||
int ic;
|
|
||||||
int method, flags;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
ic = getc(fp);
|
|
||||||
if (ic != 0x1f || getc(fp) != 0x8b)
|
|
||||||
return false; // not gzip
|
|
||||||
method = getc(fp);
|
|
||||||
flags = getc(fp);
|
|
||||||
|
|
||||||
/* quick sanity checks */
|
|
||||||
if (method == EOF || flags == EOF)
|
|
||||||
return false;
|
|
||||||
if (method != ZipFileRO::kCompressDeflated)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
/* skip over 4 bytes of mod time, 1 byte XFL, 1 byte OS */
|
|
||||||
for (i = 0; i < 6; i++)
|
|
||||||
(void) getc(fp);
|
|
||||||
/* consume "extra" field, if present */
|
|
||||||
if ((flags & FEXTRA) != 0) {
|
|
||||||
int len;
|
|
||||||
|
|
||||||
len = getc(fp);
|
|
||||||
len |= getc(fp) << 8;
|
|
||||||
while (len-- && getc(fp) != EOF)
|
|
||||||
;
|
|
||||||
}
|
|
||||||
/* consume filename, if present */
|
|
||||||
if ((flags & FNAME) != 0) {
|
|
||||||
do {
|
|
||||||
ic = getc(fp);
|
|
||||||
} while (ic != 0 && ic != EOF);
|
|
||||||
}
|
|
||||||
/* consume comment, if present */
|
|
||||||
if ((flags & FCOMMENT) != 0) {
|
|
||||||
do {
|
|
||||||
ic = getc(fp);
|
|
||||||
} while (ic != 0 && ic != EOF);
|
|
||||||
}
|
|
||||||
/* consume 16-bit header CRC, if present */
|
|
||||||
if ((flags & FHCRC) != 0) {
|
|
||||||
(void) getc(fp);
|
|
||||||
(void) getc(fp);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (feof(fp) || ferror(fp))
|
|
||||||
return false;
|
|
||||||
|
|
||||||
/* seek to the end; CRC and length are in the last 8 bytes */
|
|
||||||
long curPosn = ftell(fp);
|
|
||||||
unsigned char buf[8];
|
|
||||||
fseek(fp, -8, SEEK_END);
|
|
||||||
*pCompressedLen = ftell(fp) - curPosn;
|
|
||||||
|
|
||||||
if (fread(buf, 1, 8, fp) != 8)
|
|
||||||
return false;
|
|
||||||
/* seek back to start of compressed data */
|
|
||||||
fseek(fp, curPosn, SEEK_SET);
|
|
||||||
|
|
||||||
*pCompressionMethod = method;
|
|
||||||
*pCRC32 = ZipFileRO::get4LE(&buf[0]);
|
|
||||||
*pUncompressedLen = ZipFileRO::get4LE(&buf[4]);
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
|
@ -25,7 +25,6 @@
|
||||||
#include <sys/stat.h>
|
#include <sys/stat.h>
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
#include <errno.h>
|
#include <errno.h>
|
||||||
#include <assert.h>
|
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
|
|
||||||
#if defined(HAVE_PTHREADS)
|
#if defined(HAVE_PTHREADS)
|
||||||
|
@ -38,56 +37,6 @@ using namespace android;
|
||||||
|
|
||||||
namespace android {
|
namespace android {
|
||||||
|
|
||||||
/*
|
|
||||||
* Get a file's type.
|
|
||||||
*/
|
|
||||||
FileType getFileType(const char* fileName)
|
|
||||||
{
|
|
||||||
struct stat sb;
|
|
||||||
|
|
||||||
if (stat(fileName, &sb) < 0) {
|
|
||||||
if (errno == ENOENT || errno == ENOTDIR)
|
|
||||||
return kFileTypeNonexistent;
|
|
||||||
else {
|
|
||||||
fprintf(stderr, "getFileType got errno=%d on '%s'\n",
|
|
||||||
errno, fileName);
|
|
||||||
return kFileTypeUnknown;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if (S_ISREG(sb.st_mode))
|
|
||||||
return kFileTypeRegular;
|
|
||||||
else if (S_ISDIR(sb.st_mode))
|
|
||||||
return kFileTypeDirectory;
|
|
||||||
else if (S_ISCHR(sb.st_mode))
|
|
||||||
return kFileTypeCharDev;
|
|
||||||
else if (S_ISBLK(sb.st_mode))
|
|
||||||
return kFileTypeBlockDev;
|
|
||||||
else if (S_ISFIFO(sb.st_mode))
|
|
||||||
return kFileTypeFifo;
|
|
||||||
#ifdef HAVE_SYMLINKS
|
|
||||||
else if (S_ISLNK(sb.st_mode))
|
|
||||||
return kFileTypeSymlink;
|
|
||||||
else if (S_ISSOCK(sb.st_mode))
|
|
||||||
return kFileTypeSocket;
|
|
||||||
#endif
|
|
||||||
else
|
|
||||||
return kFileTypeUnknown;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get a file's modification date.
|
|
||||||
*/
|
|
||||||
time_t getFileModDate(const char* fileName)
|
|
||||||
{
|
|
||||||
struct stat sb;
|
|
||||||
|
|
||||||
if (stat(fileName, &sb) < 0)
|
|
||||||
return (time_t) -1;
|
|
||||||
|
|
||||||
return sb.st_mtime;
|
|
||||||
}
|
|
||||||
|
|
||||||
struct sysprop_change_callback_info {
|
struct sysprop_change_callback_info {
|
||||||
sysprop_change_callback callback;
|
sysprop_change_callback callback;
|
||||||
int priority;
|
int priority;
|
||||||
|
|
|
@ -10,8 +10,7 @@ test_src_files := \
|
||||||
LruCache_test.cpp \
|
LruCache_test.cpp \
|
||||||
String8_test.cpp \
|
String8_test.cpp \
|
||||||
Unicode_test.cpp \
|
Unicode_test.cpp \
|
||||||
Vector_test.cpp \
|
Vector_test.cpp
|
||||||
ZipFileRO_test.cpp
|
|
||||||
|
|
||||||
shared_libraries := \
|
shared_libraries := \
|
||||||
libz \
|
libz \
|
||||||
|
|
|
@ -1,64 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (C) 2011 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.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LOG_TAG "ZipFileRO_test"
|
|
||||||
#include <utils/Log.h>
|
|
||||||
#include <utils/ZipFileRO.h>
|
|
||||||
|
|
||||||
#include <gtest/gtest.h>
|
|
||||||
|
|
||||||
#include <fcntl.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
namespace android {
|
|
||||||
|
|
||||||
class ZipFileROTest : public testing::Test {
|
|
||||||
protected:
|
|
||||||
virtual void SetUp() {
|
|
||||||
}
|
|
||||||
|
|
||||||
virtual void TearDown() {
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
TEST_F(ZipFileROTest, ZipTimeConvertSuccess) {
|
|
||||||
struct tm t;
|
|
||||||
|
|
||||||
// 2011-06-29 14:40:40
|
|
||||||
long when = 0x3EDD7514;
|
|
||||||
|
|
||||||
ZipFileRO::zipTimeToTimespec(when, &t);
|
|
||||||
|
|
||||||
EXPECT_EQ(2011, t.tm_year + 1900)
|
|
||||||
<< "Year was improperly converted.";
|
|
||||||
|
|
||||||
EXPECT_EQ(6, t.tm_mon)
|
|
||||||
<< "Month was improperly converted.";
|
|
||||||
|
|
||||||
EXPECT_EQ(29, t.tm_mday)
|
|
||||||
<< "Day was improperly converted.";
|
|
||||||
|
|
||||||
EXPECT_EQ(14, t.tm_hour)
|
|
||||||
<< "Hour was improperly converted.";
|
|
||||||
|
|
||||||
EXPECT_EQ(40, t.tm_min)
|
|
||||||
<< "Minute was improperly converted.";
|
|
||||||
|
|
||||||
EXPECT_EQ(40, t.tm_sec)
|
|
||||||
<< "Second was improperly converted.";
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
Loading…
Reference in New Issue