Author: zooey Date: 2011-01-28 00:17:03 +0100 (Fri, 28 Jan 2011) New Revision: 40301 Changeset: http://dev.haiku-os.org/changeset/40301 Added: haiku/trunk/headers/os/package/PackageInfo.h haiku/trunk/headers/private/package/hpkg/ haiku/trunk/headers/private/package/hpkg/BlockBufferCache.h haiku/trunk/headers/private/package/hpkg/BufferCache.h haiku/trunk/headers/private/package/hpkg/DataOutput.h haiku/trunk/headers/private/package/hpkg/DataReader.h haiku/trunk/headers/private/package/hpkg/ErrorOutput.h haiku/trunk/headers/private/package/hpkg/FDCloser.h haiku/trunk/headers/private/package/hpkg/PackageAttributeValue.h haiku/trunk/headers/private/package/hpkg/PackageData.h haiku/trunk/headers/private/package/hpkg/PackageDataReader.h haiku/trunk/headers/private/package/hpkg/PackageEntry.h haiku/trunk/headers/private/package/hpkg/PackageEntryAttribute.h haiku/trunk/headers/private/package/hpkg/PackageReader.h haiku/trunk/headers/private/package/hpkg/PackageWriter.h haiku/trunk/headers/private/package/hpkg/Stacker.h haiku/trunk/headers/private/package/hpkg/Strings.h haiku/trunk/headers/private/package/hpkg/ZlibCompressionBase.h haiku/trunk/headers/private/package/hpkg/ZlibCompressor.h haiku/trunk/headers/private/package/hpkg/ZlibDecompressor.h haiku/trunk/headers/private/package/hpkg/haiku_package.h haiku/trunk/src/bin/package/StandardErrorOutput.cpp haiku/trunk/src/bin/package/StandardErrorOutput.h haiku/trunk/src/kits/package/PackageInfo.cpp haiku/trunk/src/kits/package/hpkg/ haiku/trunk/src/kits/package/hpkg/BlockBufferCache.cpp haiku/trunk/src/kits/package/hpkg/BufferCache.cpp haiku/trunk/src/kits/package/hpkg/DataOutput.cpp haiku/trunk/src/kits/package/hpkg/DataReader.cpp haiku/trunk/src/kits/package/hpkg/ErrorOutput.cpp haiku/trunk/src/kits/package/hpkg/PackageData.cpp haiku/trunk/src/kits/package/hpkg/PackageDataReader.cpp haiku/trunk/src/kits/package/hpkg/PackageEntry.cpp haiku/trunk/src/kits/package/hpkg/PackageEntryAttribute.cpp haiku/trunk/src/kits/package/hpkg/PackageReader.cpp haiku/trunk/src/kits/package/hpkg/PackageWriter.cpp haiku/trunk/src/kits/package/hpkg/Strings.cpp haiku/trunk/src/kits/package/hpkg/ZlibCompressionBase.cpp haiku/trunk/src/kits/package/hpkg/ZlibCompressor.cpp haiku/trunk/src/kits/package/hpkg/ZlibDecompressor.cpp Removed: haiku/trunk/headers/private/haiku_package/ haiku/trunk/headers/private/package/hpkg/haiku_package.h haiku/trunk/src/bin/package/BlockBufferCache.cpp haiku/trunk/src/bin/package/BlockBufferCache.h haiku/trunk/src/bin/package/BufferCache.cpp haiku/trunk/src/bin/package/BufferCache.h haiku/trunk/src/bin/package/DataOutput.cpp haiku/trunk/src/bin/package/DataOutput.h haiku/trunk/src/bin/package/DataReader.cpp haiku/trunk/src/bin/package/DataReader.h haiku/trunk/src/bin/package/ErrorOutput.cpp haiku/trunk/src/bin/package/ErrorOutput.h haiku/trunk/src/bin/package/FDCloser.h haiku/trunk/src/bin/package/PackageAttributeValue.h haiku/trunk/src/bin/package/PackageData.cpp haiku/trunk/src/bin/package/PackageData.h haiku/trunk/src/bin/package/PackageDataReader.cpp haiku/trunk/src/bin/package/PackageDataReader.h haiku/trunk/src/bin/package/PackageEntry.cpp haiku/trunk/src/bin/package/PackageEntry.h haiku/trunk/src/bin/package/PackageEntryAttribute.cpp haiku/trunk/src/bin/package/PackageEntryAttribute.h haiku/trunk/src/bin/package/PackageReader.cpp haiku/trunk/src/bin/package/PackageReader.h haiku/trunk/src/bin/package/PackageWriter.cpp haiku/trunk/src/bin/package/PackageWriter.h haiku/trunk/src/bin/package/Stacker.h haiku/trunk/src/bin/package/StandardErrorOutput.cpp haiku/trunk/src/bin/package/StandardErrorOutput.h haiku/trunk/src/bin/package/Strings.cpp haiku/trunk/src/bin/package/Strings.h haiku/trunk/src/bin/package/compression/ Modified: haiku/trunk/headers/os/package/Attributes.h haiku/trunk/headers/os/package/PackageRoster.h haiku/trunk/src/add-ons/kernel/file_systems/packagefs/BlockBufferCacheKernel.h haiku/trunk/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.cpp haiku/trunk/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.h haiku/trunk/src/add-ons/kernel/file_systems/packagefs/Jamfile haiku/trunk/src/add-ons/kernel/file_systems/packagefs/PackageFile.cpp haiku/trunk/src/add-ons/kernel/file_systems/packagefs/PackageFile.h haiku/trunk/src/add-ons/kernel/file_systems/packagefs/PackageNodeAttribute.h haiku/trunk/src/add-ons/kernel/file_systems/packagefs/Volume.cpp haiku/trunk/src/bin/package/Jamfile haiku/trunk/src/bin/package/command_create.cpp haiku/trunk/src/bin/package/command_dump.cpp haiku/trunk/src/bin/package/command_extract.cpp haiku/trunk/src/bin/package/command_list.cpp haiku/trunk/src/bin/package/package.cpp haiku/trunk/src/kits/package/Attributes.cpp haiku/trunk/src/kits/package/Jamfile haiku/trunk/src/kits/package/RepositoryConfig.cpp Log: More work on package kit: * added class BPackageInfo, which contains packaging attributes of a package (the values relevant for package management) * implemented parser (mostly) for reading a BPackageInfo from a config file (.PackageInfo) in order to pass them on to the PackageWriter when creating a package * pulled hpkg-related stuff from bin/package into the package kit * adjusted packagefs-Volume to skip .PackageInfo files when populating the mountpoint, as those files shouldn't appear as part of an activated package Modified: haiku/trunk/headers/os/package/Attributes.h =================================================================== --- haiku/trunk/headers/os/package/Attributes.h 2011-01-27 22:30:25 UTC (rev 40300) +++ haiku/trunk/headers/os/package/Attributes.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -15,8 +15,9 @@ extern const char* kPackageVersionAttribute; // attributes kept local to packages -extern const char* kPackageCopyrightAttribute; -extern const char* kPackageLicenseAttribute; +extern const char* kPackageCopyrightsAttribute; +extern const char* kPackageLicensesAttribute; +extern const char* kPackagePackagerAttribute; extern const char* kPackageProvidesAttribute; extern const char* kPackageRequiresAttribute; Added: haiku/trunk/headers/os/package/PackageInfo.h =================================================================== --- haiku/trunk/headers/os/package/PackageInfo.h (rev 0) +++ haiku/trunk/headers/os/package/PackageInfo.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,183 @@ +/* + * Copyright 2011, Oliver Tappe <zooey@xxxxxxxxxxxxxxx> + * Distributed under the terms of the MIT License. + */ +#ifndef _PACKAGE__PACKAGE_INFO_H_ +#define _PACKAGE__PACKAGE_INFO_H_ + + +#include <ObjectList.h> +#include <String.h> + + +class BEntry; + + +namespace BPackageKit { + + +enum BPackageInfoIndex { + B_PACKAGE_INFO_NAME = 0, + B_PACKAGE_INFO_SUMMARY, // single line, 72 chars max + B_PACKAGE_INFO_DESCRIPTION, // multiple lines possible + B_PACKAGE_INFO_VENDOR, // e.g. "Haiku Project" + B_PACKAGE_INFO_PACKAGER, // e-mail address preferred + B_PACKAGE_INFO_ARCHITECTURE, + B_PACKAGE_INFO_VERSION, + B_PACKAGE_INFO_COPYRIGHTS, // list + B_PACKAGE_INFO_LICENSES, // list + B_PACKAGE_INFO_PROVIDES, // list + B_PACKAGE_INFO_REQUIRES, // list + // + B_PACKAGE_INFO_ENUM_COUNT, +}; + + +enum BPackageArchitecture { + B_PACKAGE_ARCHITECTURE_NONE = 0, + B_PACKAGE_ARCHITECTURE_X86, + B_PACKAGE_ARCHITECTURE_X86_GCC2, + // + B_PACKAGE_ARCHITECTURE_ENUM_COUNT, +}; + + +class BPackageVersion { +public: + void MakeEmpty() {} +}; + + +class BPackageProvision { +public: + int Compare(const BPackageProvision& other) const + { + return fX.Compare(other.fX); + } +private: + BString fX; +}; + + +class BPackageRequirement { +public: + int Compare(const BPackageRequirement& other) const + { + return fX.Compare(other.fX); + } +private: + BString fX; +}; + + +/* + * Keeps a list of package info elements (e.g. name, version, vendor, ...) which + * will be converted to package attributes when creating a package. Usually, + * these elements have been parsed from a ".PackageInfo"-file. + * Alternatively, the package reader populates a BPackageInfo object by + * collecting package attributes from an existing package. + */ +class BPackageInfo { +public: + struct ParseErrorListener { + virtual ~ParseErrorListener(); + virtual void OnError(const BString& msg, int line, int col) = 0; + }; + +public: + BPackageInfo(); + ~BPackageInfo(); + + status_t ReadFromConfigFile( + const BEntry& packageInfoEntry, + ParseErrorListener* listener = NULL); + status_t ReadFromConfigString( + const BString& packageInfoString, + ParseErrorListener* listener = NULL); + + status_t InitCheck() const; + + const BString& Name() const; + const BString& Summary() const; + const BString& Description() const; + const BString& Vendor() const; + const BString& Packager() const; + + BPackageArchitecture Architecture() const; + + const BPackageVersion& Version() const; + + const BObjectList<BString>& Copyrights() const; + const BObjectList<BString>& Licenses() const; + + const BObjectList<BPackageRequirement>& Requirements() const; + const BObjectList<BPackageProvision>& Provisions() const; + + void SetName(const BString& name); + void SetSummary(const BString& summary); + void SetDescription(const BString& description); + void SetVendor(const BString& vendor); + void SetPackager(const BString& packager); + + void SetArchitecture( + BPackageArchitecture architecture); + + void SetVersion(const BPackageVersion& version); + + void ClearCopyrights(); + status_t AddCopyright(const BString& copyright); + status_t RemoveCopyright(const BString& copyright); + + void ClearLicenses(); + status_t AddLicense(const BString& license); + status_t RemoveLicense(const BString& license); + + void ClearProvisions(); + status_t AddProvision( + const BPackageProvision& provision); + status_t RemoveProvision( + const BPackageProvision& provision); + + void ClearRequirements(); + status_t AddRequirement( + const BPackageRequirement& requirement); + status_t RemoveRequirement( + const BPackageRequirement& requirement); + + void MakeEmpty(); + +public: + static status_t GetElementName( + BPackageInfoIndex index, + const char** name); + +private: + class Parser; + friend class Parser; + + static const char* kElementNames[]; + static const char* kArchitectureNames[]; + +private: + BString fName; + BString fSummary; + BString fDescription; + BString fVendor; + BString fPackager; + + BPackageArchitecture fArchitecture; + + BPackageVersion fVersion; + + BObjectList<BString> fCopyrights; + BObjectList<BString> fLicenses; + + BObjectList<BPackageProvision> fProvisions; + BObjectList<BPackageRequirement> fRequirements; +}; + + +} // namespace BPackageKit + + +#endif // _PACKAGE__PACKAGE_INFO_H_ Modified: haiku/trunk/headers/os/package/PackageRoster.h =================================================================== --- haiku/trunk/headers/os/package/PackageRoster.h 2011-01-27 22:30:25 UTC (rev 40300) +++ haiku/trunk/headers/os/package/PackageRoster.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -2,8 +2,8 @@ * Copyright 2011, Haiku, Inc. * Distributed under the terms of the MIT License. */ -#ifndef _PACKAGE__ROSTER_H_ -#define _PACKAGE__ROSTER_H_ +#ifndef _PACKAGE__PACKAGE_ROSTER_H_ +#define _PACKAGE__PACKAGE_ROSTER_H_ #include <Entry.h> @@ -68,4 +68,4 @@ } // namespace BPackageKit -#endif // _PACKAGE__ROSTER_H_ +#endif // _PACKAGE__PACKAGE_ROSTER_H_ Copied: haiku/trunk/headers/private/package/hpkg/BlockBufferCache.h (from rev 40260, haiku/trunk/src/bin/package/BlockBufferCache.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/BlockBufferCache.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/BlockBufferCache.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,71 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_ +#define _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_ + + +#include <package/hpkg/BufferCache.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +class BlockBufferCache : public BufferCache { +public: + BlockBufferCache(size_t blockSize, + uint32 maxCachedBlocks); + virtual ~BlockBufferCache(); + + virtual status_t Init(); + + virtual CachedBuffer* GetBuffer(size_t size, + CachedBuffer** owner = NULL, + bool* _newBuffer = NULL); + virtual void PutBufferAndCache(CachedBuffer** owner); + virtual void PutBuffer(CachedBuffer** owner); + + virtual bool Lock() = 0; + virtual void Unlock() = 0; + +private: + typedef DoublyLinkedList<CachedBuffer> BufferList; + +private: + CachedBuffer* _AllocateBuffer(size_t size, + CachedBuffer** owner, bool* _newBuffer); + // object must not be locked + +private: + size_t fBlockSize; + uint32 fMaxCachedBlocks; + uint32 fAllocatedBlocks; + BufferList fUnusedBuffers; + BufferList fCachedBuffers; +}; + + +class BlockBufferCacheNoLock : public BlockBufferCache { +public: + BlockBufferCacheNoLock(size_t blockSize, + uint32 maxCachedBlocks); + virtual ~BlockBufferCacheNoLock(); + + virtual bool Lock(); + virtual void Unlock(); +}; + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_ Copied: haiku/trunk/headers/private/package/hpkg/BufferCache.h (from rev 40260, haiku/trunk/src/bin/package/BufferCache.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/BufferCache.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/BufferCache.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,105 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef _PACKAGE__HPKG__BUFFER_CACHE_H_ +#define _PACKAGE__HPKG__BUFFER_CACHE_H_ + + +#include <stddef.h> + +#include <util/DoublyLinkedList.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +class CachedBuffer : public DoublyLinkedListLinkImpl<CachedBuffer> { +public: + CachedBuffer(size_t size); + ~CachedBuffer(); + + void* Buffer() const { return fBuffer; } + size_t Size() const { return fSize; } + + + // implementation private + CachedBuffer** Owner() const { return fOwner; } + void SetOwner(CachedBuffer** owner) + { fOwner = owner; } + + void SetCached(bool cached) { fCached = cached; } + bool IsCached() const { return fCached; } + +private: + CachedBuffer** fOwner; + void* fBuffer; + size_t fSize; + bool fCached; +}; + + +class BufferCache { +public: + virtual ~BufferCache(); + + virtual CachedBuffer* GetBuffer(size_t size, + CachedBuffer** owner = NULL, + bool* _newBuffer = NULL) = 0; + virtual void PutBufferAndCache(CachedBuffer** owner) = 0; + // caller is buffer owner and wants the + // buffer cached, if possible + virtual void PutBuffer(CachedBuffer** owner) = 0; + // puts the buffer for good, owner might + // have called PutBufferAndCache() before + // and might not own a buffer anymore +}; + + +class CachedBufferPutter { +public: + CachedBufferPutter(BufferCache* cache, CachedBuffer** owner) + : + fCache(cache), + fOwner(owner), + fBuffer(NULL) + { + } + + CachedBufferPutter(BufferCache* cache, CachedBuffer* buffer) + : + fCache(cache), + fOwner(NULL), + fBuffer(buffer) + { + } + + ~CachedBufferPutter() + { + if (fCache != NULL) { + if (fOwner != NULL) + fCache->PutBufferAndCache(fOwner); + else if (fBuffer != NULL) + fCache->PutBuffer(&fBuffer); + } + } + +private: + BufferCache* fCache; + CachedBuffer** fOwner; + CachedBuffer* fBuffer; +}; + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // _PACKAGE__HPKG__BUFFER_CACHE_H_ Copied: haiku/trunk/headers/private/package/hpkg/DataOutput.h (from rev 40260, haiku/trunk/src/bin/package/DataOutput.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/DataOutput.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/DataOutput.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,49 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef DATA_OUTPUT_H +#define DATA_OUTPUT_H + + +#include <SupportDefs.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +class DataOutput { +public: + virtual ~DataOutput(); + + virtual status_t WriteData(const void* buffer, size_t size) = 0; +}; + + +class BufferDataOutput : public DataOutput { +public: + BufferDataOutput(void* buffer, size_t size); + + size_t BytesWritten() const { return fBytesWritten; } + + virtual status_t WriteData(const void* buffer, size_t size); + +private: + void* fBuffer; + size_t fSize; + size_t fBytesWritten; +}; + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // DATA_OUTPUT_H Copied: haiku/trunk/headers/private/package/hpkg/DataReader.h (from rev 40260, haiku/trunk/src/bin/package/DataReader.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/DataReader.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/DataReader.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,75 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef DATA_READER_H +#define DATA_READER_H + + +#include <SupportDefs.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +class DataReader { +public: + virtual ~DataReader(); + + virtual status_t ReadData(off_t offset, void* buffer, + size_t size) = 0; +}; + + +class FDDataReader : public DataReader { +public: + FDDataReader(int fd); + + virtual status_t ReadData(off_t offset, void* buffer, + size_t size); + +private: + int fFD; +}; + + +class AttributeDataReader : public DataReader { +public: + AttributeDataReader(int fd, + const char* attribute, uint32 type); + + virtual status_t ReadData(off_t offset, void* buffer, + size_t size); + +private: + int fFD; + uint32 fType; + const char* fAttribute; +}; + + +class BufferDataReader : public DataReader { +public: + BufferDataReader(const void* data, size_t size); + + virtual status_t ReadData(off_t offset, void* buffer, + size_t size); + +private: + const void* fData; + size_t fSize; +}; + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // DATA_READER_H Copied: haiku/trunk/headers/private/package/hpkg/ErrorOutput.h (from rev 40260, haiku/trunk/src/bin/package/ErrorOutput.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/ErrorOutput.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/ErrorOutput.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,38 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef ERROR_OUTPUT_H +#define ERROR_OUTPUT_H + + +#include <stdarg.h> + +#include <SupportDefs.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +class ErrorOutput { +public: + virtual ~ErrorOutput(); + + virtual void PrintErrorVarArgs(const char* format, + va_list args) = 0; + void PrintError(const char* format, ...); +}; + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // ERROR_OUTPUT_H Copied: haiku/trunk/headers/private/package/hpkg/FDCloser.h (from rev 40260, haiku/trunk/src/bin/package/FDCloser.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/FDCloser.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/FDCloser.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,41 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef FD_CLOSER_H +#define FD_CLOSER_H + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +struct FDCloser { + FDCloser(int fd) + : + fFD(fd) + { + } + + ~FDCloser() + { + if (fFD >= 0) + close(fFD); + } + +private: + int fFD; +}; + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // FD_CLOSER_H Copied: haiku/trunk/headers/private/package/hpkg/PackageAttributeValue.h (from rev 40260, haiku/trunk/src/bin/package/PackageAttributeValue.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/PackageAttributeValue.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/PackageAttributeValue.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,161 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef PACKAGE_ATTRIBUTE_VALUE_H +#define PACKAGE_ATTRIBUTE_VALUE_H + + +#include <string.h> + +#include <package/hpkg/haiku_package.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +struct PackageAttributeValue { + union { + int64 signedInt; + uint64 unsignedInt; + const char* string; + struct { + uint64 size; + union { + uint64 offset; + uint8 raw[B_HPKG_MAX_INLINE_DATA_SIZE]; + }; + } data; + }; + uint8 type; + uint8 encoding; + +public: + inline PackageAttributeValue(); + + inline void SetTo(int8 value); + inline void SetTo(uint8 value); + inline void SetTo(int16 value); + inline void SetTo(uint16 value); + inline void SetTo(int32 value); + inline void SetTo(uint32 value); + inline void SetTo(int64 value); + inline void SetTo(uint64 value); + inline void SetTo(const char* value); + inline void SetToData(uint64 size, uint64 offset); + inline void SetToData(uint64 size, const void* rawData); +}; + + +PackageAttributeValue::PackageAttributeValue() + : + type(B_HPKG_ATTRIBUTE_TYPE_INVALID) +{ +} + + +void +PackageAttributeValue::SetTo(int8 value) +{ + signedInt = value; + type = B_HPKG_ATTRIBUTE_TYPE_INT; +} + + +void +PackageAttributeValue::SetTo(uint8 value) +{ + unsignedInt = value; + type = B_HPKG_ATTRIBUTE_TYPE_UINT; +} + + +void +PackageAttributeValue::SetTo(int16 value) +{ + signedInt = value; + type = B_HPKG_ATTRIBUTE_TYPE_INT; +} + + +void +PackageAttributeValue::SetTo(uint16 value) +{ + unsignedInt = value; + type = B_HPKG_ATTRIBUTE_TYPE_UINT; +} + + +void +PackageAttributeValue::SetTo(int32 value) +{ + signedInt = value; + type = B_HPKG_ATTRIBUTE_TYPE_INT; +} + + +void +PackageAttributeValue::SetTo(uint32 value) +{ + unsignedInt = value; + type = B_HPKG_ATTRIBUTE_TYPE_UINT; +} + + +void +PackageAttributeValue::SetTo(int64 value) +{ + signedInt = value; + type = B_HPKG_ATTRIBUTE_TYPE_INT; +} + + +void +PackageAttributeValue::SetTo(uint64 value) +{ + unsignedInt = value; + type = B_HPKG_ATTRIBUTE_TYPE_UINT; +} + + +void +PackageAttributeValue::SetTo(const char* value) +{ + string = value; + type = B_HPKG_ATTRIBUTE_TYPE_STRING; +} + + +void +PackageAttributeValue::SetToData(uint64 size, uint64 offset) +{ + data.size = size; + data.offset = offset; + type = B_HPKG_ATTRIBUTE_TYPE_RAW; + encoding = B_HPKG_ATTRIBUTE_ENCODING_RAW_HEAP; +} + + +void +PackageAttributeValue::SetToData(uint64 size, const void* rawData) +{ + data.size = size; + if (size > 0) + memcpy(data.raw, rawData, size); + type = B_HPKG_ATTRIBUTE_TYPE_RAW; + encoding = B_HPKG_ATTRIBUTE_ENCODING_RAW_INLINE; +} + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // PACKAGE_ATTRIBUTE_VALUE_H Copied: haiku/trunk/headers/private/package/hpkg/PackageData.h (from rev 40260, haiku/trunk/src/bin/package/PackageData.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/PackageData.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/PackageData.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,66 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef PACKAGE_DATA_H +#define PACKAGE_DATA_H + + +#include <package/hpkg/haiku_package.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +class PackageData { +public: + PackageData(); + + uint64 CompressedSize() const + { return fCompressedSize; } + uint64 UncompressedSize() const + { return fUncompressedSize; } + uint64 Offset() const + { return fEncodedInline ? 0 : fOffset; } + uint32 Compression() const { return fCompression; } + uint32 ChunkSize() const { return fChunkSize; } + + bool IsEncodedInline() const + { return fEncodedInline; } + const uint8* InlineData() const { return fInlineData; } + + void SetData(uint64 size, uint64 offset); + void SetData(uint8 size, const void* data); + + void SetCompression(uint32 compression) + { fCompression = compression; } + void SetUncompressedSize(uint64 size) + { fUncompressedSize = size; } + void SetChunkSize(uint32 size) + { fChunkSize = size; } + +private: + uint64 fCompressedSize; + uint64 fUncompressedSize; + union { + uint64 fOffset; + uint8 fInlineData[B_HPKG_MAX_INLINE_DATA_SIZE]; + }; + uint32 fChunkSize; + uint32 fCompression; + bool fEncodedInline; +}; + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // PACKAGE_DATA_H Copied: haiku/trunk/headers/private/package/hpkg/PackageDataReader.h (from rev 40260, haiku/trunk/src/bin/package/PackageDataReader.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/PackageDataReader.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/PackageDataReader.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,65 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef PACKAGE_DATA_READER_H +#define PACKAGE_DATA_READER_H + + +#include <package/hpkg/DataReader.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +class BufferCache; +class DataOutput; +class PackageData; + + +class PackageDataReader : public DataReader { +public: + PackageDataReader(DataReader* dataReader); + virtual ~PackageDataReader(); + + virtual status_t Init(const PackageData& data) = 0; + + virtual status_t ReadData(off_t offset, void* buffer, + size_t size); + virtual status_t ReadDataToOutput(off_t offset, size_t size, + DataOutput* output) = 0; + + virtual uint64 Size() const = 0; + virtual size_t BlockSize() const = 0; + +protected: + DataReader* fDataReader; +}; + + +class PackageDataReaderFactory { +public: + PackageDataReaderFactory( + BufferCache* bufferCache); + + status_t CreatePackageDataReader(DataReader* dataReader, + const PackageData& data, + PackageDataReader*& _reader); + +private: + BufferCache* fBufferCache; +}; + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // PACKAGE_DATA_READER_H Copied: haiku/trunk/headers/private/package/hpkg/PackageEntry.h (from rev 40260, haiku/trunk/src/bin/package/PackageEntry.h) =================================================================== --- haiku/trunk/headers/private/package/hpkg/PackageEntry.h (rev 0) +++ haiku/trunk/headers/private/package/hpkg/PackageEntry.h 2011-01-27 23:17:03 UTC (rev 40301) @@ -0,0 +1,98 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@xxxxxxx + * Distributed under the terms of the MIT License. + */ +#ifndef PACKAGE_ENTRY_H +#define PACKAGE_ENTRY_H + + +#include <sys/stat.h> + +#include <package/hpkg/PackageData.h> + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + +class PackageEntry { +public: + PackageEntry(PackageEntry* parent, + const char* name); + + const PackageEntry* Parent() const { return fParent; } + const char* Name() const { return fName; } + void* UserToken() const { return fUserToken; } + + mode_t Mode() const { return fMode; } + + const timespec& AccessTime() const + { return fAccessTime; } + const timespec& ModifiedTime() const + { return fModifiedTime; } + const timespec& CreationTime() const + { return fCreationTime; } + + PackageData& Data() { return fData; } + + const char* SymlinkPath() const { return fSymlinkPath; } + [... truncated: 6932 lines follow ...]