break dependency on utils/ZipEntry.h and utils/ZipFile.h, get rid of... (7e83f043) · Commits · e / os / android_frameworks_native-old

include/utils/Socket.h

deleted100644 → 0

+0 −80

Original line number	Original line	Diff line number	Diff line
	/*
	* 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.
	*/

	//
	// Socket class. Modeled after Java classes.
	//
	#ifndef _RUNTIME_SOCKET_H
	#define _RUNTIME_SOCKET_H

	#include <utils/inet_address.h>
	#include <sys/types.h>

	namespace android {

	/*
	* Basic socket class, needed to abstract away the differences between
	* BSD sockets and WinSock. This establishes a streaming network
	* connection (TCP/IP) to somebody.
	*/
	class Socket {
	public:
	Socket(void);
	~Socket(void);

	// Create a connection to somewhere.
	// Return 0 on success.
	int connect(const char* host, int port);
	int connect(const InetAddress* addr, int port);


	// Close the socket. Don't try to use this object again after
	// calling this. Returns false on failure.
	bool close(void);

	// If we created the socket without an address, we can use these
	// to finish the connection. Returns 0 on success.
	int bind(const SocketAddress& bindPoint);
	int connect(const SocketAddress& endPoint);

	// Here we deviate from the traditional object-oriented fanciness
	// and just provide read/write operators instead of getters for
	// objects that abstract a stream.
	//
	// Standard read/write semantics.
	int read(void* buf, ssize_t len) const;
	int write(const void* buf, ssize_t len) const;

	// This must be called once, at program startup.
	static bool bootInit(void);
	static void finalShutdown(void);

	private:
	// Internal function that establishes a connection.
	int doConnect(const InetSocketAddress& addr);

	unsigned long mSock; // holds SOCKET or int

	static bool mBootInitialized;
	};


	// debug -- unit tests
	void TestSockets(void);

	}; // namespace android

	#endif // _RUNTIME_SOCKET_H

include/utils/ZipEntry.h

deleted100644 → 0

+0 −345

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2006 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.
	*/

	//
	// Zip archive entries.
	//
	// The ZipEntry class is tightly meshed with the ZipFile class.
	//
	#ifndef __LIBS_ZIPENTRY_H
	#define __LIBS_ZIPENTRY_H

	#include "Errors.h"

	#include <stdlib.h>
	#include <stdio.h>

	namespace android {

	class ZipFile;

	/*
	* ZipEntry objects represent a single entry in a Zip archive.
	*
	* You can use one of these to get or set information about an entry, but
	* there are no functions here for accessing the data itself. (We could
	* tuck a pointer to the ZipFile in here for convenience, but that raises
	* the likelihood of using ZipEntry objects after discarding the ZipFile.)
	*
	* File information is stored in two places: next to the file data (the Local
	* File Header, and possibly a Data Descriptor), and at the end of the file
	* (the Central Directory Entry). The two must be kept in sync.
	*/
	class ZipEntry {
	public:
	friend class ZipFile;

	ZipEntry(void)
	: mDeleted(false), mMarked(false)
	{}
	~ZipEntry(void) {}

	/*
	* Returns "true" if the data is compressed.
	*/
	bool isCompressed(void) const {
	return mCDE.mCompressionMethod != kCompressStored;
	}
	int getCompressionMethod(void) const { return mCDE.mCompressionMethod; }

	/*
	* Return the uncompressed length.
	*/
	off_t getUncompressedLen(void) const { return mCDE.mUncompressedSize; }

	/*
	* Return the compressed length. For uncompressed data, this returns
	* the same thing as getUncompresesdLen().
	*/
	off_t getCompressedLen(void) const { return mCDE.mCompressedSize; }

	/*
	* Return the absolute file offset of the start of the compressed or
	* uncompressed data.
	*/
	off_t getFileOffset(void) const {
	return mCDE.mLocalHeaderRelOffset +
	LocalFileHeader::kLFHLen +
	mLFH.mFileNameLength +
	mLFH.mExtraFieldLength;
	}

	/*
	* Return the data CRC.
	*/
	unsigned long getCRC32(void) const { return mCDE.mCRC32; }

	/*
	* Return file modification time in UNIX seconds-since-epoch.
	*/
	time_t getModWhen(void) const;

	/*
	* Return the archived file name.
	*/
	const char* getFileName(void) const { return (const char*) mCDE.mFileName; }

	/*
	* Application-defined "mark". Can be useful when synchronizing the
	* contents of an archive with contents on disk.
	*/
	bool getMarked(void) const { return mMarked; }
	void setMarked(bool val) { mMarked = val; }

	/*
	* Some basic functions for raw data manipulation. "LE" means
	* Little Endian.
	*/
	static inline unsigned short getShortLE(const unsigned char* buf) {
	return buf[0] \| (buf[1] << 8);
	}
	static inline unsigned long getLongLE(const unsigned char* buf) {
	return buf[0] \| (buf[1] << 8) \| (buf[2] << 16) \| (buf[3] << 24);
	}
	static inline void putShortLE(unsigned char* buf, short val) {
	buf[0] = (unsigned char) val;
	buf[1] = (unsigned char) (val >> 8);
	}
	static inline void putLongLE(unsigned char* buf, long val) {
	buf[0] = (unsigned char) val;
	buf[1] = (unsigned char) (val >> 8);
	buf[2] = (unsigned char) (val >> 16);
	buf[3] = (unsigned char) (val >> 24);
	}

	/* defined for Zip archives */
	enum {
	kCompressStored = 0, // no compression
	// shrunk = 1,
	// reduced 1 = 2,
	// reduced 2 = 3,
	// reduced 3 = 4,
	// reduced 4 = 5,
	// imploded = 6,
	// tokenized = 7,
	kCompressDeflated = 8, // standard deflate
	// Deflate64 = 9,
	// lib imploded = 10,
	// reserved = 11,
	// bzip2 = 12,
	};

	/*
	* Deletion flag. If set, the entry will be removed on the next
	* call to "flush".
	*/
	bool getDeleted(void) const { return mDeleted; }

	protected:
	/*
	* Initialize the structure from the file, which is pointing at
	* our Central Directory entry.
	*/
	status_t initFromCDE(FILE* fp);

	/*
	* Initialize the structure for a new file. We need the filename
	* and comment so that we can properly size the LFH area. The
	* filename is mandatory, the comment is optional.
	*/
	void initNew(const char* fileName, const char* comment);

	/*
	* Initialize the structure with the contents of a ZipEntry from
	* another file.
	*/
	status_t initFromExternal(const ZipFile* pZipFile, const ZipEntry* pEntry);

	/*
	* Add some pad bytes to the LFH. We do this by adding or resizing
	* the "extra" field.
	*/
	status_t addPadding(int padding);

	/*
	* Set information about the data for this entry.
	*/
	void setDataInfo(long uncompLen, long compLen, unsigned long crc32,
	int compressionMethod);

	/*
	* Set the modification date.
	*/
	void setModWhen(time_t when);

	/*
	* Return the offset of the local file header.
	*/
	off_t getLFHOffset(void) const { return mCDE.mLocalHeaderRelOffset; }

	/*
	* Set the offset of the local file header, relative to the start of
	* the current file.
	*/
	void setLFHOffset(off_t offset) {
	mCDE.mLocalHeaderRelOffset = (long) offset;
	}

	/* mark for deletion; used by ZipFile::remove() */
	void setDeleted(void) { mDeleted = true; }

	private:
	/* these are private and not defined */
	ZipEntry(const ZipEntry& src);
	ZipEntry& operator=(const ZipEntry& src);

	/* returns "true" if the CDE and the LFH agree */
	bool compareHeaders(void) const;
	void copyCDEtoLFH(void);

	bool mDeleted; // set if entry is pending deletion
	bool mMarked; // app-defined marker

	/*
	* Every entry in the Zip archive starts off with one of these.
	*/
	class LocalFileHeader {
	public:
	LocalFileHeader(void) :
	mVersionToExtract(0),
	mGPBitFlag(0),
	mCompressionMethod(0),
	mLastModFileTime(0),
	mLastModFileDate(0),
	mCRC32(0),
	mCompressedSize(0),
	mUncompressedSize(0),
	mFileNameLength(0),
	mExtraFieldLength(0),
	mFileName(NULL),
	mExtraField(NULL)
	{}
	virtual ~LocalFileHeader(void) {
	delete[] mFileName;
	delete[] mExtraField;
	}

	status_t read(FILE* fp);
	status_t write(FILE* fp);

	// unsigned long mSignature;
	unsigned short mVersionToExtract;
	unsigned short mGPBitFlag;
	unsigned short mCompressionMethod;
	unsigned short mLastModFileTime;
	unsigned short mLastModFileDate;
	unsigned long mCRC32;
	unsigned long mCompressedSize;
	unsigned long mUncompressedSize;
	unsigned short mFileNameLength;
	unsigned short mExtraFieldLength;
	unsigned char* mFileName;
	unsigned char* mExtraField;

	enum {
	kSignature = 0x04034b50,
	kLFHLen = 30, // LocalFileHdr len, excl. var fields
	};

	void dump(void) const;
	};

	/*
	* Every entry in the Zip archive has one of these in the "central
	* directory" at the end of the file.
	*/
	class CentralDirEntry {
	public:
	CentralDirEntry(void) :
	mVersionMadeBy(0),
	mVersionToExtract(0),
	mGPBitFlag(0),
	mCompressionMethod(0),
	mLastModFileTime(0),
	mLastModFileDate(0),
	mCRC32(0),
	mCompressedSize(0),
	mUncompressedSize(0),
	mFileNameLength(0),
	mExtraFieldLength(0),
	mFileCommentLength(0),
	mDiskNumberStart(0),
	mInternalAttrs(0),
	mExternalAttrs(0),
	mLocalHeaderRelOffset(0),
	mFileName(NULL),
	mExtraField(NULL),
	mFileComment(NULL)
	{}
	virtual ~CentralDirEntry(void) {
	delete[] mFileName;
	delete[] mExtraField;
	delete[] mFileComment;
	}

	status_t read(FILE* fp);
	status_t write(FILE* fp);

	// unsigned long mSignature;
	unsigned short mVersionMadeBy;
	unsigned short mVersionToExtract;
	unsigned short mGPBitFlag;
	unsigned short mCompressionMethod;
	unsigned short mLastModFileTime;
	unsigned short mLastModFileDate;
	unsigned long mCRC32;
	unsigned long mCompressedSize;
	unsigned long mUncompressedSize;
	unsigned short mFileNameLength;
	unsigned short mExtraFieldLength;
	unsigned short mFileCommentLength;
	unsigned short mDiskNumberStart;
	unsigned short mInternalAttrs;
	unsigned long mExternalAttrs;
	unsigned long mLocalHeaderRelOffset;
	unsigned char* mFileName;
	unsigned char* mExtraField;
	unsigned char* mFileComment;

	void dump(void) const;

	enum {
	kSignature = 0x02014b50,
	kCDELen = 46, // CentralDirEnt len, excl. var fields
	};
	};

	enum {
	//kDataDescriptorSignature = 0x08074b50, // currently unused
	kDataDescriptorLen = 16, // four 32-bit fields

	kDefaultVersion = 20, // need deflate, nothing much else
	kDefaultMadeBy = 0x0317, // 03=UNIX, 17=spec v2.3
	kUsesDataDescr = 0x0008, // GPBitFlag bit 3
	};

	LocalFileHeader mLFH;
	CentralDirEntry mCDE;
	};

	}; // namespace android

	#endif // __LIBS_ZIPENTRY_H

include/utils/ZipFile.h

deleted100644 → 0

+0 −269

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2006 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.
	*/

	//
	// General-purpose Zip archive access. This class allows both reading and
	// writing to Zip archives, including deletion of existing entries.
	//
	#ifndef __LIBS_ZIPFILE_H
	#define __LIBS_ZIPFILE_H

	#include "ZipEntry.h"
	#include "Vector.h"
	#include "Errors.h"
	#include <stdio.h>

	namespace android {

	/*
	* Manipulate a Zip archive.
	*
	* Some changes will not be visible in the until until "flush" is called.
	*
	* The correct way to update a file archive is to make all changes to a
	* copy of the archive in a temporary file, and then unlink/rename over
	* the original after everything completes. Because we're only interested
	* in using this for packaging, we don't worry about such things. Crashing
	* after making changes and before flush() completes could leave us with
	* an unusable Zip archive.
	*/
	class ZipFile {
	public:
	ZipFile(void)
	: mZipFp(NULL), mReadOnly(false), mNeedCDRewrite(false)
	{}
	~ZipFile(void) {
	if (!mReadOnly)
	flush();
	if (mZipFp != NULL)
	fclose(mZipFp);
	discardEntries();
	}

	/*
	* Open a new or existing archive.
	*/
	typedef enum {
	kOpenReadOnly = 0x01,
	kOpenReadWrite = 0x02,
	kOpenCreate = 0x04, // create if it doesn't exist
	kOpenTruncate = 0x08, // if it exists, empty it
	};
	status_t open(const char* zipFileName, int flags);

	/*
	* Add a file to the end of the archive. Specify whether you want the
	* library to try to store it compressed.
	*
	* If "storageName" is specified, the archive will use that instead
	* of "fileName".
	*
	* If there is already an entry with the same name, the call fails.
	* Existing entries with the same name must be removed first.
	*
	* If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
	*/
	status_t add(const char* fileName, int compressionMethod,
	ZipEntry** ppEntry)
	{
	return add(fileName, fileName, compressionMethod, ppEntry);
	}
	status_t add(const char* fileName, const char* storageName,
	int compressionMethod, ZipEntry** ppEntry)
	{
	return addCommon(fileName, NULL, 0, storageName,
	ZipEntry::kCompressStored,
	compressionMethod, ppEntry);
	}

	/*
	* Add a file that is already compressed with gzip.
	*
	* If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
	*/
	status_t addGzip(const char* fileName, const char* storageName,
	ZipEntry** ppEntry)
	{
	return addCommon(fileName, NULL, 0, storageName,
	ZipEntry::kCompressDeflated,
	ZipEntry::kCompressDeflated, ppEntry);
	}

	/*
	* Add a file from an in-memory data buffer.
	*
	* If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
	*/
	status_t add(const void* data, size_t size, const char* storageName,
	int compressionMethod, ZipEntry** ppEntry)
	{
	return addCommon(NULL, data, size, storageName,
	ZipEntry::kCompressStored,
	compressionMethod, ppEntry);
	}

	/*
	* Add an entry by copying it from another zip file. If "padding" is
	* nonzero, the specified number of bytes will be added to the "extra"
	* field in the header.
	*
	* If "ppEntry" is non-NULL, a pointer to the new entry will be returned.
	*/
	status_t add(const ZipFile* pSourceZip, const ZipEntry* pSourceEntry,
	int padding, ZipEntry** ppEntry);

	/*
	* Mark an entry as having been removed. It is not actually deleted
	* from the archive or our internal data structures until flush() is
	* called.
	*/
	status_t remove(ZipEntry* pEntry);

	/*
	* Flush changes. If mNeedCDRewrite is set, this writes the central dir.
	*/
	status_t flush(void);

	/*
	* Expand the data into the buffer provided. The buffer must hold
	* at least <uncompressed len> bytes. Variation expands directly
	* to a file.
	*
	* Returns "false" if an error was encountered in the compressed data.
	*/
	//bool uncompress(const ZipEntry* pEntry, void* buf) const;
	//bool uncompress(const ZipEntry* pEntry, FILE* fp) const;
	void* uncompress(const ZipEntry* pEntry);

	/*
	* Get an entry, by name. Returns NULL if not found.
	*
	* Does not return entries pending deletion.
	*/
	ZipEntry* getEntryByName(const char* fileName) const;

	/*
	* Get the Nth entry in the archive.
	*
	* This will return an entry that is pending deletion.
	*/
	int getNumEntries(void) const { return mEntries.size(); }
	ZipEntry* getEntryByIndex(int idx) const;

	private:
	/* these are private and not defined */
	ZipFile(const ZipFile& src);
	ZipFile& operator=(const ZipFile& src);

	class EndOfCentralDir {
	public:
	EndOfCentralDir(void) :
	mDiskNumber(0),
	mDiskWithCentralDir(0),
	mNumEntries(0),
	mTotalNumEntries(0),
	mCentralDirSize(0),
	mCentralDirOffset(0),
	mCommentLen(0),
	mComment(NULL)
	{}
	virtual ~EndOfCentralDir(void) {
	delete[] mComment;
	}

	status_t readBuf(const unsigned char* buf, int len);
	status_t write(FILE* fp);

	//unsigned long mSignature;
	unsigned short mDiskNumber;
	unsigned short mDiskWithCentralDir;
	unsigned short mNumEntries;
	unsigned short mTotalNumEntries;
	unsigned long mCentralDirSize;
	unsigned long mCentralDirOffset; // offset from first disk
	unsigned short mCommentLen;
	unsigned char* mComment;

	enum {
	kSignature = 0x06054b50,
	kEOCDLen = 22, // EndOfCentralDir len, excl. comment

	kMaxCommentLen = 65535, // longest possible in ushort
	kMaxEOCDSearch = kMaxCommentLen + EndOfCentralDir::kEOCDLen,

	};

	void dump(void) const;
	};


	/* read all entries in the central dir */
	status_t readCentralDir(void);

	/* crunch deleted entries out */
	status_t crunchArchive(void);

	/* clean up mEntries */
	void discardEntries(void);

	/* common handler for all "add" functions */
	status_t addCommon(const char* fileName, const void* data, size_t size,
	const char* storageName, int sourceType, int compressionMethod,
	ZipEntry** ppEntry);

	/* copy all of "srcFp" into "dstFp" */
	status_t copyFpToFp(FILE* dstFp, FILE* srcFp, unsigned long* pCRC32);
	/* copy all of "data" into "dstFp" */
	status_t copyDataToFp(FILE* dstFp,
	const void* data, size_t size, unsigned long* pCRC32);
	/* copy some of "srcFp" into "dstFp" */
	status_t copyPartialFpToFp(FILE* dstFp, FILE* srcFp, long length,
	unsigned long* pCRC32);
	/* like memmove(), but on parts of a single file */
	status_t filemove(FILE* fp, off_t dest, off_t src, size_t n);
	/* compress all of "srcFp" into "dstFp", using Deflate */
	status_t compressFpToFp(FILE* dstFp, FILE* srcFp,
	const void* data, size_t size, unsigned long* pCRC32);

	/* get modification date from a file descriptor */
	time_t getModTime(int fd);

	/*
	* We use stdio FILE*, which gives us buffering but makes dealing
	* with files >2GB awkward. Until we support Zip64, we're fine.
	*/
	FILE* mZipFp; // Zip file pointer

	/* one of these per file */
	EndOfCentralDir mEOCD;

	/* did we open this read-only? */
	bool mReadOnly;

	/* set this when we trash the central dir */
	bool mNeedCDRewrite;

	/*
	* One ZipEntry per entry in the zip file. I'm using pointers instead
	* of objects because it's easier than making operator= work for the
	* classes and sub-classes.
	*/
	Vector<ZipEntry*> mEntries;
	};

	}; // namespace android

	#endif // __LIBS_ZIPFILE_H

include/utils/inet_address.h

deleted100644 → 0

+0 −103

Original line number	Original line	Diff line number	Diff line
	/*
	* 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.
	*/

	//
	// Internet address classes. Modeled after Java classes.
	//
	#ifndef _RUNTIME_INET_ADDRESS_H
	#define _RUNTIME_INET_ADDRESS_H

	#ifdef HAVE_ANDROID_OS
	#error DO NOT USE THIS FILE IN THE DEVICE BUILD
	#endif


	namespace android {

	/*
	* This class holds Internet addresses. Perhaps more useful is its
	* ability to look up addresses by name.
	*
	* Invoke one of the static factory methods to create a new object.
	*/
	class InetAddress {
	public:
	virtual ~InetAddress(void);

	// create from w.x.y.z or foo.bar.com notation
	static InetAddress* getByName(const char* host);

	// copy-construction
	InetAddress(const InetAddress& orig);

	const void* getAddress(void) const { return mAddress; }
	int getAddressLength(void) const { return mLength; }
	const char* getHostName(void) const { return mName; }

	private:
	InetAddress(void);
	// assignment (private)
	InetAddress& operator=(const InetAddress& addr);

	// use a void* here so we don't have to expose actual socket headers
	void* mAddress; // this is really a ptr to sockaddr_in
	int mLength;
	char* mName;
	};


	/*
	* Base class for socket addresses.
	*/
	class SocketAddress {
	public:
	SocketAddress() {}
	virtual ~SocketAddress() {}
	};


	/*
	* Internet address class. This combines an InetAddress with a port.
	*/
	class InetSocketAddress : public SocketAddress {
	public:
	InetSocketAddress() :
	mAddress(0), mPort(-1)
	{}
	~InetSocketAddress(void) {
	delete mAddress;
	}

	// Create an address with a host wildcard (useful for servers).
	bool create(int port);
	// Create an address with the specified host and port.
	bool create(const InetAddress* addr, int port);
	// Create an address with the specified host and port. Does the
	// hostname lookup.
	bool create(const char* host, int port);

	const InetAddress* getAddress(void) const { return mAddress; }
	const int getPort(void) const { return mPort; }
	const char* getHostName(void) const { return mAddress->getHostName(); }

	private:
	InetAddress* mAddress;
	int mPort;
	};

	}; // namespace android

	#endif // _RUNTIME_INET_ADDRESS_H

libs/utils/Android.mk

+1 −22

File changed.

Preview size limit exceeded, changes collapsed.