diff --git a/headers/os/package/Attributes.h b/headers/os/package/Attributes.h index 0b5fe1c794..507aa3ae20 100644 --- a/headers/os/package/Attributes.h +++ b/headers/os/package/Attributes.h @@ -15,8 +15,9 @@ extern const char* kPackageVendorAttribute; 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; diff --git a/headers/os/package/PackageInfo.h b/headers/os/package/PackageInfo.h new file mode 100644 index 0000000000..d208d8571e --- /dev/null +++ b/headers/os/package/PackageInfo.h @@ -0,0 +1,183 @@ +/* + * Copyright 2011, Oliver Tappe + * Distributed under the terms of the MIT License. + */ +#ifndef _PACKAGE__PACKAGE_INFO_H_ +#define _PACKAGE__PACKAGE_INFO_H_ + + +#include +#include + + +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& Copyrights() const; + const BObjectList& Licenses() const; + + const BObjectList& Requirements() const; + const BObjectList& 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 fCopyrights; + BObjectList fLicenses; + + BObjectList fProvisions; + BObjectList fRequirements; +}; + + +} // namespace BPackageKit + + +#endif // _PACKAGE__PACKAGE_INFO_H_ diff --git a/headers/os/package/PackageRoster.h b/headers/os/package/PackageRoster.h index f1b44b40e3..1bb452468e 100644 --- a/headers/os/package/PackageRoster.h +++ b/headers/os/package/PackageRoster.h @@ -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 @@ -68,4 +68,4 @@ private: } // namespace BPackageKit -#endif // _PACKAGE__ROSTER_H_ +#endif // _PACKAGE__PACKAGE_ROSTER_H_ diff --git a/src/bin/package/BlockBufferCache.h b/headers/private/package/hpkg/BlockBufferCache.h similarity index 78% rename from src/bin/package/BlockBufferCache.h rename to headers/private/package/hpkg/BlockBufferCache.h index 89ba9351dc..137e3ea20a 100644 --- a/src/bin/package/BlockBufferCache.h +++ b/headers/private/package/hpkg/BlockBufferCache.h @@ -2,11 +2,18 @@ * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. * Distributed under the terms of the MIT License. */ -#ifndef BLOCK_BUFFER_CACHE_H -#define BLOCK_BUFFER_CACHE_H +#ifndef _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_ +#define _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_ -#include "BufferCache.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class BlockBufferCache : public BufferCache { @@ -54,4 +61,11 @@ public: }; -#endif // BLOCK_BUFFER_CACHE_H +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // _PACKAGE__HPKG__BLOCK_BUFFER_CACHE_H_ diff --git a/src/bin/package/BufferCache.h b/headers/private/package/hpkg/BufferCache.h similarity index 86% rename from src/bin/package/BufferCache.h rename to headers/private/package/hpkg/BufferCache.h index e8e058422f..e3ca3b9b44 100644 --- a/src/bin/package/BufferCache.h +++ b/headers/private/package/hpkg/BufferCache.h @@ -2,8 +2,8 @@ * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. * Distributed under the terms of the MIT License. */ -#ifndef BUFFER_CACHE_H -#define BUFFER_CACHE_H +#ifndef _PACKAGE__HPKG__BUFFER_CACHE_H_ +#define _PACKAGE__HPKG__BUFFER_CACHE_H_ #include @@ -11,6 +11,13 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + class CachedBuffer : public DoublyLinkedListLinkImpl { public: CachedBuffer(size_t size); @@ -88,4 +95,11 @@ private: }; -#endif // BUFFER_CACHE_H +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + +#endif // _PACKAGE__HPKG__BUFFER_CACHE_H_ diff --git a/src/bin/package/DataOutput.h b/headers/private/package/hpkg/DataOutput.h similarity index 80% rename from src/bin/package/DataOutput.h rename to headers/private/package/hpkg/DataOutput.h index ecf13688b4..646834ccef 100644 --- a/src/bin/package/DataOutput.h +++ b/headers/private/package/hpkg/DataOutput.h @@ -9,6 +9,13 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + class DataOutput { public: virtual ~DataOutput(); @@ -32,4 +39,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // DATA_OUTPUT_H diff --git a/src/bin/package/DataReader.h b/headers/private/package/hpkg/DataReader.h similarity index 87% rename from src/bin/package/DataReader.h rename to headers/private/package/hpkg/DataReader.h index be6a897be0..86493362bd 100644 --- a/src/bin/package/DataReader.h +++ b/headers/private/package/hpkg/DataReader.h @@ -9,6 +9,13 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + class DataReader { public: virtual ~DataReader(); @@ -58,4 +65,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // DATA_READER_H diff --git a/src/bin/package/ErrorOutput.h b/headers/private/package/hpkg/ErrorOutput.h similarity index 73% rename from src/bin/package/ErrorOutput.h rename to headers/private/package/hpkg/ErrorOutput.h index d4ccf3de0d..bbb066e0dd 100644 --- a/src/bin/package/ErrorOutput.h +++ b/headers/private/package/hpkg/ErrorOutput.h @@ -11,6 +11,13 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + class ErrorOutput { public: virtual ~ErrorOutput(); @@ -21,4 +28,11 @@ public: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // ERROR_OUTPUT_H diff --git a/src/bin/package/FDCloser.h b/headers/private/package/hpkg/FDCloser.h similarity index 66% rename from src/bin/package/FDCloser.h rename to headers/private/package/hpkg/FDCloser.h index b21f9ad226..79a4dbefab 100644 --- a/src/bin/package/FDCloser.h +++ b/headers/private/package/hpkg/FDCloser.h @@ -6,6 +6,13 @@ #define FD_CLOSER_H +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + struct FDCloser { FDCloser(int fd) : @@ -24,4 +31,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // FD_CLOSER_H diff --git a/src/bin/package/PackageAttributeValue.h b/headers/private/package/hpkg/PackageAttributeValue.h similarity index 92% rename from src/bin/package/PackageAttributeValue.h rename to headers/private/package/hpkg/PackageAttributeValue.h index f7fcaefe66..dfded18b42 100644 --- a/src/bin/package/PackageAttributeValue.h +++ b/headers/private/package/hpkg/PackageAttributeValue.h @@ -8,7 +8,14 @@ #include -#include +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { struct PackageAttributeValue { @@ -144,4 +151,11 @@ PackageAttributeValue::SetToData(uint64 size, const void* rawData) } +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // PACKAGE_ATTRIBUTE_VALUE_H diff --git a/src/bin/package/PackageData.h b/headers/private/package/hpkg/PackageData.h similarity index 86% rename from src/bin/package/PackageData.h rename to headers/private/package/hpkg/PackageData.h index b02014ad81..c239a82a01 100644 --- a/src/bin/package/PackageData.h +++ b/headers/private/package/hpkg/PackageData.h @@ -6,7 +6,14 @@ #define PACKAGE_DATA_H -#include +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class PackageData { @@ -49,4 +56,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // PACKAGE_DATA_H diff --git a/src/bin/package/PackageDataReader.h b/headers/private/package/hpkg/PackageDataReader.h similarity index 84% rename from src/bin/package/PackageDataReader.h rename to headers/private/package/hpkg/PackageDataReader.h index d1f8d8342d..7913792356 100644 --- a/src/bin/package/PackageDataReader.h +++ b/headers/private/package/hpkg/PackageDataReader.h @@ -6,7 +6,14 @@ #define PACKAGE_DATA_READER_H -#include "DataReader.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class BufferCache; @@ -48,4 +55,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // PACKAGE_DATA_READER_H diff --git a/src/bin/package/PackageEntry.h b/headers/private/package/hpkg/PackageEntry.h similarity index 91% rename from src/bin/package/PackageEntry.h rename to headers/private/package/hpkg/PackageEntry.h index 2c22f6b4b9..c1bc00c792 100644 --- a/src/bin/package/PackageEntry.h +++ b/headers/private/package/hpkg/PackageEntry.h @@ -8,7 +8,14 @@ #include -#include "PackageData.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class PackageEntry { @@ -81,4 +88,11 @@ PackageEntry::SetPermissions(uint32 permissions) } +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // PACKAGE_ENTRY_H diff --git a/src/bin/package/PackageEntryAttribute.h b/headers/private/package/hpkg/PackageEntryAttribute.h similarity index 74% rename from src/bin/package/PackageEntryAttribute.h rename to headers/private/package/hpkg/PackageEntryAttribute.h index ef76e2fd81..3094a3d82a 100644 --- a/src/bin/package/PackageEntryAttribute.h +++ b/headers/private/package/hpkg/PackageEntryAttribute.h @@ -6,7 +6,14 @@ #define PACKAGE_ENTRY_ATTRIBUTE_H -#include "PackageData.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class PackageEntryAttribute { @@ -27,4 +34,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // PACKAGE_ENTRY_ATTRIBUTE_H diff --git a/src/bin/package/PackageReader.h b/headers/private/package/hpkg/PackageReader.h similarity index 95% rename from src/bin/package/PackageReader.h rename to headers/private/package/hpkg/PackageReader.h index 4711d0687b..cdb6f2d8d6 100644 --- a/src/bin/package/PackageReader.h +++ b/headers/private/package/hpkg/PackageReader.h @@ -10,7 +10,14 @@ #include -#include "PackageAttributeValue.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class ErrorOutput; @@ -163,4 +170,11 @@ PackageReader::_Read(Type& _value) } +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // PACKAGE_READER_H diff --git a/src/bin/package/PackageWriter.h b/headers/private/package/hpkg/PackageWriter.h similarity index 93% rename from src/bin/package/PackageWriter.h rename to headers/private/package/hpkg/PackageWriter.h index 4c0f513436..1f8354e2e0 100644 --- a/src/bin/package/PackageWriter.h +++ b/headers/private/package/hpkg/PackageWriter.h @@ -9,12 +9,23 @@ #include #include -#include "Strings.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class DataReader; struct hpkg_header; +namespace BPackageKit { + class BPackageInfo; +} + class PackageWriter { public: @@ -121,4 +132,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // PACKAGE_WRITER_H diff --git a/src/bin/package/Stacker.h b/headers/private/package/hpkg/Stacker.h similarity index 79% rename from src/bin/package/Stacker.h rename to headers/private/package/hpkg/Stacker.h index 312c80184e..34bcd178eb 100644 --- a/src/bin/package/Stacker.h +++ b/headers/private/package/hpkg/Stacker.h @@ -6,6 +6,13 @@ #define STACKER_H +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + template class Stacker { public: @@ -37,4 +44,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // STACKER_H diff --git a/src/bin/package/Strings.h b/headers/private/package/hpkg/Strings.h similarity index 89% rename from src/bin/package/Strings.h rename to headers/private/package/hpkg/Strings.h index 184cc69b1c..78d03c0e97 100644 --- a/src/bin/package/Strings.h +++ b/headers/private/package/hpkg/Strings.h @@ -9,6 +9,13 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + uint32 hash_string(const char* string); @@ -79,4 +86,11 @@ struct CachedStringUsageGreater { }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // STRINGS_H diff --git a/src/bin/package/compression/ZlibCompressionBase.h b/headers/private/package/hpkg/ZlibCompressionBase.h similarity index 67% rename from src/bin/package/compression/ZlibCompressionBase.h rename to headers/private/package/hpkg/ZlibCompressionBase.h index f27db828d1..960f4186cd 100644 --- a/src/bin/package/compression/ZlibCompressionBase.h +++ b/headers/private/package/hpkg/ZlibCompressionBase.h @@ -9,10 +9,24 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + class ZlibCompressionBase { public: static status_t TranslateZlibError(int error); }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // ZLIB_COMPRESSION_BASE_H diff --git a/src/bin/package/compression/ZlibCompressor.h b/headers/private/package/hpkg/ZlibCompressor.h similarity index 78% rename from src/bin/package/compression/ZlibCompressor.h rename to headers/private/package/hpkg/ZlibCompressor.h index c029162df1..cd28c66185 100644 --- a/src/bin/package/compression/ZlibCompressor.h +++ b/headers/private/package/hpkg/ZlibCompressor.h @@ -8,7 +8,14 @@ #include -#include "ZlibCompressionBase.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class DataOutput; @@ -35,4 +42,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // ZLIB_COMPRESSOR_H diff --git a/src/bin/package/compression/ZlibDecompressor.h b/headers/private/package/hpkg/ZlibDecompressor.h similarity index 79% rename from src/bin/package/compression/ZlibDecompressor.h rename to headers/private/package/hpkg/ZlibDecompressor.h index c0093a54b4..8d7b0c225c 100644 --- a/src/bin/package/compression/ZlibDecompressor.h +++ b/headers/private/package/hpkg/ZlibDecompressor.h @@ -8,7 +8,14 @@ #include -#include "ZlibCompressionBase.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { class DataOutput; @@ -37,4 +44,11 @@ private: }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // ZLIB_DECOMPRESSOR_H diff --git a/headers/private/haiku_package/haiku_package.h b/headers/private/package/hpkg/haiku_package.h similarity index 94% rename from headers/private/haiku_package/haiku_package.h rename to headers/private/package/hpkg/haiku_package.h index 15a6182a8e..48315f1b30 100644 --- a/headers/private/haiku_package/haiku_package.h +++ b/headers/private/package/hpkg/haiku_package.h @@ -9,6 +9,13 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + // header struct hpkg_header { uint32 magic; // "hpkg" @@ -141,6 +148,10 @@ enum { #define B_HPKG_MAX_INLINE_DATA_SIZE 8 +// name of file containing package information (in package's root folder) +#define B_HPKG_PACKAGE_INFO_FILE_NAME ".PackageInfo" + + // default values enum { B_HPKG_DEFAULT_FILE_TYPE = B_HPKG_FILE_TYPE_FILE, @@ -152,4 +163,11 @@ enum { }; +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit + + #endif // _HAIKU_PACKAGE_H diff --git a/src/add-ons/kernel/file_systems/packagefs/BlockBufferCacheKernel.h b/src/add-ons/kernel/file_systems/packagefs/BlockBufferCacheKernel.h index a75b7417a5..4f80a476f7 100644 --- a/src/add-ons/kernel/file_systems/packagefs/BlockBufferCacheKernel.h +++ b/src/add-ons/kernel/file_systems/packagefs/BlockBufferCacheKernel.h @@ -8,7 +8,10 @@ #include -#include "BlockBufferCache.h" +#include + + +using BPackageKit::BHaikuPackage::BPrivate::BlockBufferCache; class BlockBufferCacheKernel : public BlockBufferCache { diff --git a/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.cpp b/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.cpp index 46b74a1134..9646e9f6b8 100644 --- a/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.cpp +++ b/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.cpp @@ -8,7 +8,7 @@ #include -#include +#include static const uint32 kMaxCachedBuffers = 32; diff --git a/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.h b/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.h index 814a5debb0..bf8b3faa54 100644 --- a/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.h +++ b/src/add-ons/kernel/file_systems/packagefs/GlobalFactory.h @@ -6,8 +6,13 @@ #define GLOBAL_FACTORY_H +#include +#include + #include "BlockBufferCacheKernel.h" -#include "PackageDataReader.h" + + +using namespace BPackageKit::BHaikuPackage::BPrivate; class GlobalFactory { diff --git a/src/add-ons/kernel/file_systems/packagefs/Jamfile b/src/add-ons/kernel/file_systems/packagefs/Jamfile index 67364d59be..7b0f5d085c 100644 --- a/src/add-ons/kernel/file_systems/packagefs/Jamfile +++ b/src/add-ons/kernel/file_systems/packagefs/Jamfile @@ -3,7 +3,7 @@ SubDir HAIKU_TOP src add-ons kernel file_systems packagefs ; UseLibraryHeaders zlib ; UsePrivateKernelHeaders ; -UsePrivateHeaders haiku_package shared ; +UsePrivateHeaders shared ; DEFINES += B_ENABLE_INCOMPLETE_POSIX_AT_SUPPORT ; # TODO: Remove when it is complete! @@ -46,8 +46,7 @@ HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES = ; -SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src bin package ] ; -SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src bin package compression ] ; +SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package hpkg ] ; KernelAddon packagefs diff --git a/src/add-ons/kernel/file_systems/packagefs/PackageFile.cpp b/src/add-ons/kernel/file_systems/packagefs/PackageFile.cpp index 23a80cf6a6..52cd63f65d 100644 --- a/src/add-ons/kernel/file_systems/packagefs/PackageFile.cpp +++ b/src/add-ons/kernel/file_systems/packagefs/PackageFile.cpp @@ -11,15 +11,18 @@ #include -#include "DataOutput.h" -#include "DataReader.h" -#include "PackageDataReader.h" +#include +#include +#include #include "DebugSupport.h" #include "GlobalFactory.h" #include "Package.h" +using namespace BPackageKit::BHaikuPackage::BPrivate; + + // #pragma mark - DataAccessor diff --git a/src/add-ons/kernel/file_systems/packagefs/PackageFile.h b/src/add-ons/kernel/file_systems/packagefs/PackageFile.h index a6bf2d29b3..6d27352d93 100644 --- a/src/add-ons/kernel/file_systems/packagefs/PackageFile.h +++ b/src/add-ons/kernel/file_systems/packagefs/PackageFile.h @@ -6,11 +6,14 @@ #define PACKAGE_FILE_H -#include "PackageData.h" +#include #include "PackageLeafNode.h" +using BPackageKit::BHaikuPackage::BPrivate::PackageData; + + class PackageFile : public PackageLeafNode { public: PackageFile(Package* package, mode_t mode, diff --git a/src/add-ons/kernel/file_systems/packagefs/PackageNodeAttribute.h b/src/add-ons/kernel/file_systems/packagefs/PackageNodeAttribute.h index a395e7fbc1..f75e8ec1fc 100644 --- a/src/add-ons/kernel/file_systems/packagefs/PackageNodeAttribute.h +++ b/src/add-ons/kernel/file_systems/packagefs/PackageNodeAttribute.h @@ -8,9 +8,11 @@ #include -#include "PackageData.h" +#include +using BPackageKit::BHaikuPackage::BPrivate::PackageData; + class PackageNode; diff --git a/src/add-ons/kernel/file_systems/packagefs/Volume.cpp b/src/add-ons/kernel/file_systems/packagefs/Volume.cpp index 20597ec247..48ddbc163f 100644 --- a/src/add-ons/kernel/file_systems/packagefs/Volume.cpp +++ b/src/add-ons/kernel/file_systems/packagefs/Volume.cpp @@ -23,11 +23,11 @@ #include -#include "ErrorOutput.h" -#include "FDCloser.h" -#include "PackageEntry.h" -#include "PackageEntryAttribute.h" -#include "PackageReader.h" +#include +#include +#include +#include +#include #include "DebugSupport.h" #include "Directory.h" @@ -38,6 +38,9 @@ #include "PackageSymlink.h" +using namespace BPackageKit::BHaikuPackage::BPrivate; + + // node ID of the root directory static const ino_t kRootDirectoryID = 1; @@ -625,6 +628,9 @@ Volume::_AddPackageContent(Package* package, bool notify) { for (PackageNodeList::Iterator it = package->Nodes().GetIterator(); PackageNode* node = it.Next();) { + // skip over ".PackageInfo" file, it isn't part of the package content + if (strcmp(node->Name(), B_HPKG_PACKAGE_INFO_FILE_NAME) == 0) + continue; status_t error = _AddPackageContentRootNode(package, node, notify); if (error != B_OK) { _RemovePackageContent(package, node, notify); @@ -645,6 +651,10 @@ Volume::_RemovePackageContent(Package* package, PackageNode* endNode, if (node == endNode) break; + // skip over ".PackageInfo" file, it isn't part of the package content + if (strcmp(node->Name(), B_HPKG_PACKAGE_INFO_FILE_NAME) == 0) + continue; + PackageNode* nextNode = package->Nodes().GetNext(node); _RemovePackageContentRootNode(package, node, NULL, notify); node = nextNode; diff --git a/src/bin/package/Jamfile b/src/bin/package/Jamfile index 94329e874b..70c4ae3568 100644 --- a/src/bin/package/Jamfile +++ b/src/bin/package/Jamfile @@ -1,39 +1,19 @@ SubDir HAIKU_TOP src bin package ; -UseLibraryHeaders zlib ; UsePrivateHeaders kernel shared ; -UsePrivateHeaders haiku_package ; DEFINES += B_ENABLE_INCOMPLETE_POSIX_AT_SUPPORT ; # TODO: Remove when it is complete! -SEARCH_SOURCE += [ FDirName $(SUBDIR) compression ] ; - BinCommand package : - BlockBufferCache.cpp - BufferCache.cpp command_create.cpp command_dump.cpp command_extract.cpp command_list.cpp - DataOutput.cpp - DataReader.cpp - ErrorOutput.cpp package.cpp - PackageData.cpp - PackageDataReader.cpp - PackageEntry.cpp - PackageEntryAttribute.cpp - PackageReader.cpp - PackageWriter.cpp StandardErrorOutput.cpp - Strings.cpp - # compression - ZlibCompressionBase.cpp - ZlibCompressor.cpp - ZlibDecompressor.cpp : - z + package be $(TARGET_LIBSUPC++) ; diff --git a/src/bin/package/StandardErrorOutput.h b/src/bin/package/StandardErrorOutput.h index 87ea82ee0a..b1f34727e1 100644 --- a/src/bin/package/StandardErrorOutput.h +++ b/src/bin/package/StandardErrorOutput.h @@ -6,7 +6,10 @@ #define STANDARD_ERROR_OUTPUT_H -#include "ErrorOutput.h" +#include + + +using BPackageKit::BHaikuPackage::BPrivate::ErrorOutput; class StandardErrorOutput : public ErrorOutput { diff --git a/src/bin/package/command_create.cpp b/src/bin/package/command_create.cpp index 7bf1e8424e..73733f6400 100644 --- a/src/bin/package/command_create.cpp +++ b/src/bin/package/command_create.cpp @@ -4,8 +4,6 @@ */ -#include "package.h" - #include #include #include @@ -13,8 +11,17 @@ #include #include +#include + +#include +#include +#include + #include "package.h" -#include "PackageWriter.h" + + +using BPackageKit::BPackageInfo; +using BPackageKit::BHaikuPackage::BPrivate::PackageWriter; int @@ -86,6 +93,18 @@ printf("Init(): %s\n", strerror(error)); if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue; + +if (strcmp(entry->d_name, B_HPKG_PACKAGE_INFO_FILE_NAME) == 0) { + printf("parsing %s ...\n", entry->d_name); + struct ErrorListener : public BPackageInfo::ParseErrorListener { + virtual void OnError(const BString& msg, int line, int col) { + printf("*** parse error (%d:%d) -> %s\n", line, col, msg.String()); + } + } errorListener; + BEntry packageInfoEntry(entry->d_name); + BPackageInfo packageInfo; + packageInfo.ReadFromConfigFile(packageInfoEntry, &errorListener); +} error = packageWriter.AddEntry(entry->d_name); printf("AddEntry(\"%s\"): %s\n", entry->d_name, strerror(error)); if (error != B_OK) diff --git a/src/bin/package/command_dump.cpp b/src/bin/package/command_dump.cpp index dfb9a1b66d..486d80ba4c 100644 --- a/src/bin/package/command_dump.cpp +++ b/src/bin/package/command_dump.cpp @@ -4,8 +4,6 @@ */ -#include "package.h" - #include #include #include @@ -13,13 +11,17 @@ #include #include +#include +#include +#include + #include "package.h" -#include "PackageEntry.h" -#include "PackageEntryAttribute.h" -#include "PackageReader.h" #include "StandardErrorOutput.h" +using namespace BPackageKit::BHaikuPackage::BPrivate; + + struct PackageContentDumpHandler : LowLevelPackageContentHandler { PackageContentDumpHandler() : diff --git a/src/bin/package/command_extract.cpp b/src/bin/package/command_extract.cpp index a57ee6a205..c149d75ccf 100644 --- a/src/bin/package/command_extract.cpp +++ b/src/bin/package/command_extract.cpp @@ -4,8 +4,6 @@ */ -#include "package.h" - #include #include #include @@ -23,16 +21,20 @@ #include -#include "BlockBufferCache.h" -#include "FDCloser.h" +#include +#include +#include +#include +#include +#include + #include "package.h" -#include "PackageDataReader.h" -#include "PackageEntry.h" -#include "PackageEntryAttribute.h" -#include "PackageReader.h" #include "StandardErrorOutput.h" +using namespace BPackageKit::BHaikuPackage::BPrivate; + + struct PackageContentExtractHandler : PackageContentHandler { PackageContentExtractHandler(int packageFileFD) : diff --git a/src/bin/package/command_list.cpp b/src/bin/package/command_list.cpp index 175351b070..cb5461506a 100644 --- a/src/bin/package/command_list.cpp +++ b/src/bin/package/command_list.cpp @@ -4,8 +4,6 @@ */ -#include "package.h" - #include #include #include @@ -13,13 +11,17 @@ #include #include +#include +#include +#include + #include "package.h" -#include "PackageEntry.h" -#include "PackageEntryAttribute.h" -#include "PackageReader.h" #include "StandardErrorOutput.h" +using namespace BPackageKit::BHaikuPackage::BPrivate; + + struct PackageContentListHandler : PackageContentHandler { PackageContentListHandler(bool listAttributes) : diff --git a/src/bin/package/package.cpp b/src/bin/package/package.cpp index 0e3c711564..c8e9602d38 100644 --- a/src/bin/package/package.cpp +++ b/src/bin/package/package.cpp @@ -12,7 +12,7 @@ #include #include -#include "PackageWriter.h" +#include extern const char* __progname; diff --git a/src/kits/package/Attributes.cpp b/src/kits/package/Attributes.cpp index 7df7d22f10..b9067addf6 100644 --- a/src/kits/package/Attributes.cpp +++ b/src/kits/package/Attributes.cpp @@ -13,15 +13,16 @@ namespace BPackageKit { -// attributes used in package and as file attribute, too +// attributes used in package and as BFS-attribute const char* kPackageNameAttribute = "PKG:name"; const char* kPackagePlatformAttribute = "PKG:platform"; const char* kPackageVendorAttribute = "PKG:vendor"; const char* kPackageVersionAttribute = "PKG:version"; // attributes kept local to packages -const char* kPackageCopyrightAttribute = "PKG:copyright"; -const char* kPackageLicenseAttribute = "PKG:license"; +const char* kPackageCopyrightsAttribute = "PKG:copyrights"; +const char* kPackageLicensesAttribute = "PKG:licenses"; +const char* kPackagePackagerAttribute = "PKG:packager"; const char* kPackageProvidesAttribute = "PKG:provides"; const char* kPackageRequiresAttribute = "PKG:requires"; diff --git a/src/kits/package/Jamfile b/src/kits/package/Jamfile index e1f1bd1a4c..e128baf068 100644 --- a/src/kits/package/Jamfile +++ b/src/kits/package/Jamfile @@ -1,6 +1,32 @@ SubDir HAIKU_TOP src kits package ; -UsePrivateHeaders package shared ; +UseLibraryHeaders zlib ; + +UsePrivateHeaders + kernel + shared ; + +SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src kits package hpkg ] ; + +HPKG_SOURCES = + BlockBufferCache.cpp + BufferCache.cpp + DataOutput.cpp + DataReader.cpp + ErrorOutput.cpp + PackageData.cpp + PackageDataReader.cpp + PackageEntry.cpp + PackageEntryAttribute.cpp + PackageReader.cpp + PackageWriter.cpp + Strings.cpp + + # compression + ZlibCompressionBase.cpp + ZlibCompressor.cpp + ZlibDecompressor.cpp + ; SharedLibrary libpackage.so : @@ -14,6 +40,7 @@ SharedLibrary libpackage.so FetchFileJob.cpp Job.cpp JobQueue.cpp + PackageInfo.cpp PackageRoster.cpp RefreshRepositoryRequest.cpp RemoveRepositoryJob.cpp @@ -23,6 +50,8 @@ SharedLibrary libpackage.so Request.cpp TempfileManager.cpp ValidateChecksumJob.cpp + + $(HPKG_SOURCES) : - libshared.a be $(TARGET_LIBSTDC++) + libshared.a be z $(TARGET_LIBSTDC++) ; diff --git a/src/kits/package/PackageInfo.cpp b/src/kits/package/PackageInfo.cpp new file mode 100644 index 0000000000..e1f5646b75 --- /dev/null +++ b/src/kits/package/PackageInfo.cpp @@ -0,0 +1,880 @@ +#include +/* + * Copyright 2011, Oliver Tappe + * Distributed under the terms of the MIT License. + */ + + +#include + +#include +#include +#include + +#include + +#include +#include +#include + + +namespace BPackageKit { + + +namespace { + + +enum TokenType { + TOKEN_WORD, + TOKEN_QUOTED_STRING, + TOKEN_OPERATOR_ASSIGN, + TOKEN_OPERATOR_LESS, + TOKEN_OPERATOR_LESS_EQUAL, + TOKEN_OPERATOR_EQUAL, + TOKEN_OPERATOR_NOT_EQUAL, + TOKEN_OPERATOR_GREATER_EQUAL, + TOKEN_OPERATOR_GREATER, + TOKEN_OPEN_BRACKET, + TOKEN_CLOSE_BRACKET, + TOKEN_COMMA, + TOKEN_SEMICOLON, + TOKEN_COLON, + // + TOKEN_EOF, +}; + + +struct ParseError { + BString message; + const char* pos; + + ParseError(const BString& _message, const char* _pos) + : message(_message), pos(_pos) + { + } +}; + + +} // anonymous namespace + + +/* + * Parses a ".PackageInfo" file and fills a BPackageInfo object with the + * package info elements found. + */ +class BPackageInfo::Parser { +public: + Parser(ParseErrorListener* listener = NULL); + + status_t Parse(const BString& packageInfoString, + BPackageInfo* packageInfo); + +private: + struct Token; + + Token _NextToken(); + void _ParseStringValue(BString* value); + void _ParseArchitectureValue( + BPackageArchitecture* value); + void _Parse(BPackageInfo* packageInfo); + +private: + ParseErrorListener* fListener; + + const char* fPos; + int fCurrentLine; +}; + + +struct BPackageInfo::Parser::Token { + TokenType type; + BString text; + const char* pos; + + Token(TokenType _type, const char* _pos, int length = 0) + : type(_type), pos(_pos) + { + if (length != 0) { + text.SetTo(pos, length); + + if (type == TOKEN_QUOTED_STRING) { + // unescape value of quoted string + char* value = text.LockBuffer(length); + if (value == NULL) + return; + int index = 0; + int newIndex = 0; + bool lastWasEscape = false; + while (char c = value[index++]) { + if (lastWasEscape) { + lastWasEscape = false; + // map \n to newline and \t to tab + if (c == 'n') + c = '\n'; + else if (c == 't') + c = '\t'; + } else if (c == '\\') { + lastWasEscape = true; + continue; + } + value[newIndex++] = c; + } + value[newIndex] = '\0'; + text.UnlockBuffer(newIndex); + } + } + } + + operator bool() const + { + return type != TOKEN_EOF; + } +}; + + +BPackageInfo::ParseErrorListener::~ParseErrorListener() +{ +} + + +BPackageInfo::Parser::Parser(ParseErrorListener* listener) + : + fListener(listener), + fPos(NULL), + fCurrentLine(0) +{ +} + + +status_t +BPackageInfo::Parser::Parse(const BString& packageInfoString, + BPackageInfo* packageInfo) +{ + if (packageInfo == NULL) + return B_BAD_VALUE; + + fPos = packageInfoString.String(); + fCurrentLine = 1; + + try { + _Parse(packageInfo); + } catch (const ParseError& error) { + if (fListener != NULL) { + // map error position to line and column + int line = 1; + int column; + int32 offset = error.pos - packageInfoString.String(); + int32 newlinePos = packageInfoString.FindLast('\n', offset); + if (newlinePos < 0) + column = offset; + else { + column = offset - newlinePos; + do { + line++; + newlinePos = packageInfoString.FindLast('\n', + newlinePos - 1); + } while (newlinePos >= 0); + } + fListener->OnError(error.message, line, column); + } + return B_BAD_DATA; + } + + return B_OK; +} + + +BPackageInfo::Parser::Token +BPackageInfo::Parser::_NextToken() +{ + // eat any whitespace or comments +printf("1: %p\n", fPos); + bool inComment = false; + while ((inComment && *fPos != '\0') || isspace(*fPos) || *fPos == '#') { +printf("1b: %p\n", fPos); + if (*fPos == '#') + inComment = true; + else if (*fPos == '\n') { + inComment = false; + fCurrentLine++; + } + fPos++; + } + +printf("2: %p\n", fPos); + const char* tokenPos = fPos; + switch (*fPos) { + case '\0': + return Token(TOKEN_EOF, fPos); + + case ':': + fPos++; + return Token(TOKEN_COLON, tokenPos); + + case ',': + fPos++; + return Token(TOKEN_COMMA, tokenPos); + + case ';': + fPos++; + return Token(TOKEN_SEMICOLON, tokenPos); + + case '[': + fPos++; + return Token(TOKEN_OPEN_BRACKET, tokenPos); + + case ']': + fPos++; + return Token(TOKEN_CLOSE_BRACKET, tokenPos); + + case '<': + fPos++; + if (*fPos == '=') { + fPos++; + return Token(TOKEN_OPERATOR_LESS_EQUAL, tokenPos); + } + return Token(TOKEN_OPERATOR_LESS, tokenPos); + + case '=': + fPos++; + if (*fPos == '=') { + fPos++; + return Token(TOKEN_OPERATOR_EQUAL, tokenPos); + } + return Token(TOKEN_OPERATOR_ASSIGN, tokenPos); + + case '!': + if (fPos[1] == '=') { + fPos += 2; + return Token(TOKEN_OPERATOR_NOT_EQUAL, tokenPos); + } + break; + + case '>': + fPos++; + if (*fPos == '=') { + fPos++; + return Token(TOKEN_OPERATOR_GREATER_EQUAL, tokenPos); + } + return Token(TOKEN_OPERATOR_GREATER, tokenPos); + + case '"': + { + fPos++; + const char* start = fPos; + // anything until the next quote is part of the value + bool lastWasEscape = false; + while ((*fPos != '"' || lastWasEscape) && *fPos != '\0') { + if (lastWasEscape) + lastWasEscape = false; + else if (*fPos == '\\') + lastWasEscape = true; + else if (*fPos == '\n') + fCurrentLine++; + fPos++; + } + if (*fPos != '"') + throw ParseError("unterminated quoted-string", tokenPos); + const char* end = fPos++; + return Token(TOKEN_QUOTED_STRING, start, end - start); + } + + default: + { + const char* start = fPos; + while (isalnum(*fPos) || *fPos == '.' || *fPos == '-' + || *fPos == '_') { + fPos++; + } + if (fPos == start) + break; + return Token(TOKEN_WORD, start, fPos - start); + } + } + + BString error = BString("unknown token '") << *fPos << "' encountered"; + throw ParseError(error.String(), fPos); +} + + +void +BPackageInfo::Parser::_ParseStringValue(BString* value) +{ + Token string = _NextToken(); + if (string.type != TOKEN_QUOTED_STRING && string.type != TOKEN_WORD) + throw ParseError("expected quoted-string or word", string.pos); + + *value = string.text; +} + + +void +BPackageInfo::Parser::_ParseArchitectureValue(BPackageArchitecture* value) +{ + Token arch = _NextToken(); + if (arch.type == TOKEN_WORD) { + for (int i = 0; i < B_PACKAGE_ARCHITECTURE_ENUM_COUNT; ++i) { + if (arch.text.ICompare(BPackageInfo::kArchitectureNames[i]) == 0) { + *value = (BPackageArchitecture)i; + return; + } + } + } + + BString error("architecture must be one of: ["); + for (int i = 0; i < B_PACKAGE_ARCHITECTURE_ENUM_COUNT; ++i) { + if (i > 0) + error << ","; + error << BPackageInfo::kArchitectureNames[i]; + } + error << "]"; + throw ParseError(error, arch.pos); +} + + +void +BPackageInfo::Parser::_Parse(BPackageInfo* packageInfo) +{ + bool seen[B_PACKAGE_INFO_ENUM_COUNT]; + for (int i = 0; i < B_PACKAGE_INFO_ENUM_COUNT; ++i) + seen[i] = false; + + const char* const* names = BPackageInfo::kElementNames; + + while (Token t = _NextToken()) { + if (t.type != TOKEN_WORD) + throw ParseError("expected word [a variable name]", t.pos); + + Token opAssign = _NextToken(); + if (opAssign.type != TOKEN_OPERATOR_ASSIGN) { + throw ParseError("expected assignment operator ['=']", + opAssign.pos); + } + + if (t.text.ICompare(names[B_PACKAGE_INFO_NAME]) == 0) { + if (seen[B_PACKAGE_INFO_NAME]) { + BString error = BString(names[B_PACKAGE_INFO_NAME]) + << " already seen!"; + throw ParseError(error, t.pos); + } + + BString name; + _ParseStringValue(&name); + packageInfo->SetName(name); + seen[B_PACKAGE_INFO_NAME] = true; + } else if (t.text.ICompare(names[B_PACKAGE_INFO_SUMMARY]) == 0) { + if (seen[B_PACKAGE_INFO_SUMMARY]) { + BString error = BString(names[B_PACKAGE_INFO_SUMMARY]) + << " already seen!"; + throw ParseError(error, t.pos); + } + + BString summary; + _ParseStringValue(&summary); + packageInfo->SetSummary(summary); + seen[B_PACKAGE_INFO_SUMMARY] = true; + } else if (t.text.ICompare(names[B_PACKAGE_INFO_DESCRIPTION]) == 0) { + if (seen[B_PACKAGE_INFO_DESCRIPTION]) { + BString error = BString(names[B_PACKAGE_INFO_DESCRIPTION]) + << " already seen!"; + throw ParseError(error, t.pos); + } + + BString description; + _ParseStringValue(&description); + packageInfo->SetDescription(description); + seen[B_PACKAGE_INFO_DESCRIPTION] = true; + } else if (t.text.ICompare(names[B_PACKAGE_INFO_VENDOR]) == 0) { + if (seen[B_PACKAGE_INFO_VENDOR]) { + BString error = BString(names[B_PACKAGE_INFO_VENDOR]) + << " already seen!"; + throw ParseError(error, t.pos); + } + + BString vendor; + _ParseStringValue(&vendor); + packageInfo->SetVendor(vendor); + seen[B_PACKAGE_INFO_VENDOR] = true; + } else if (t.text.ICompare(names[B_PACKAGE_INFO_PACKAGER]) == 0) { + if (seen[B_PACKAGE_INFO_PACKAGER]) { + BString error = BString(names[B_PACKAGE_INFO_PACKAGER]) + << " already seen!"; + throw ParseError(error, t.pos); + } + + BString packager; + _ParseStringValue(&packager); + packageInfo->SetPackager(packager); + seen[B_PACKAGE_INFO_PACKAGER] = true; + } else if (t.text.ICompare(names[B_PACKAGE_INFO_ARCHITECTURE]) == 0) { + if (seen[B_PACKAGE_INFO_ARCHITECTURE]) { + BString error = BString(names[B_PACKAGE_INFO_ARCHITECTURE]) + << " already seen!"; + throw ParseError(error, t.pos); + } + + BPackageArchitecture architecture; + _ParseArchitectureValue(&architecture); + packageInfo->SetArchitecture(architecture); + seen[B_PACKAGE_INFO_ARCHITECTURE] = true; + } +// } else if (t.text.ICompare(names[B_PACKAGE_INFO_VERSION]) == 0) { +// if (seen[B_PACKAGE_INFO_VERSION]) { +// BString error = BString(names[B_PACKAGE_INFO_VERSION]) +// << " already seen!"; +// throw ParseError(error, t.pos); +// } +// +// BPackageVersion version; +// _ParseVersionValue(&version); +// packageInfo->SetVersion(version); +// seen[B_PACKAGE_INFO_VERSION] = true; +// } else if (t.text.ICompare(names[B_PACKAGE_INFO_COPYRIGHTS]) == 0) { +// if (seen[B_PACKAGE_INFO_COPYRIGHTS]) { +// BString error = BString(names[B_PACKAGE_INFO_COPYRIGHTS]) +// << " already seen!"; +// throw ParseError(error, t.pos); +// } +// +// BObjectList copyrights; +// _ParseStringList(©rights); +// int count = copyrights.CountItems(); +// for (int i = 0; i < count; ++i) +// packageInfo->AddCopyright(*(copyrights.ItemAt(i))); +// seen[B_PACKAGE_INFO_COPYRIGHTS] = true; +// } else if (t.text.ICompare(names[B_PACKAGE_INFO_LICENSES]) == 0) { +// if (seen[B_PACKAGE_INFO_LICENSES]) { +// BString error = BString(names[B_PACKAGE_INFO_LICENSES]) +// << " already seen!"; +// throw ParseError(error, t.pos); +// } +// +// BObjectList licenses; +// _ParseStringList(&licenses); +// int count = licenses.CountItems(); +// for (int i = 0; i < count; ++i) +// packageInfo->AddLicense(*(licenses.ItemAt(i))); +// seen[B_PACKAGE_INFO_LICENSES] = true; +// } else if (t.text.ICompare(names[B_PACKAGE_INFO_PROVIDES]) == 0) { +// if (seen[B_PACKAGE_INFO_PROVIDES]) { +// BString error = BString(names[B_PACKAGE_INFO_PROVIDES]) +// << " already seen!"; +// throw ParseError(error, t.pos); +// } +// +// BObjectList provisions; +// _ParseProvisionList(&provisions); +// int count = provisions.CountItems(); +// for (int i = 0; i < count; ++i) +// packageInfo->AddProvision(*(provisions.ItemAt(i))); +// seen[B_PACKAGE_INFO_PROVIDES] = true; +// } else if (t.text.ICompare(names[B_PACKAGE_INFO_REQUIRES]) == 0) { +// if (seen[B_PACKAGE_INFO_REQUIRES]) { +// BString error = BString(names[B_PACKAGE_INFO_REQUIRES]) +// << " already seen!"; +// throw ParseError(error, t.pos); +// } +// +// BObjectList requirements; +// _ParseRequirementList(&requirements); +// int count = requirements.CountItems(); +// for (int i = 0; i < count; ++i) +// packageInfo->AddRequirement(*(requirements.ItemAt(i))); +// seen[B_PACKAGE_INFO_REQUIRES] = true; +// } + + Token semicolon = _NextToken(); + if (semicolon.type != TOKEN_SEMICOLON) + throw ParseError("expected semicolon [';']", semicolon.pos); + } + + for (int i = 0; i < B_PACKAGE_INFO_ENUM_COUNT; ++i) { + if (!seen[i]) { + BString error = BString(names[i]) << " is not being set anywhere!"; + throw ParseError(error, fPos); + } + } +} + + +const char* BPackageInfo::kElementNames[B_PACKAGE_INFO_ENUM_COUNT] = { + "name", + "summary", + "description", + "vendor", + "packager", + "architecture", + "version", + "copyrights", + "licenses", + "provides", + "requires", +}; + + +const char* +BPackageInfo::kArchitectureNames[B_PACKAGE_ARCHITECTURE_ENUM_COUNT] = { + "no_arch", + "x86", + "x86_gcc2", +}; + + +BPackageInfo::BPackageInfo() + : + fArchitecture(B_PACKAGE_ARCHITECTURE_NONE), + fCopyrights(5, true), + fLicenses(5, true), + fProvisions(20, true), + fRequirements(20, true) +{ +} + + +BPackageInfo::~BPackageInfo() +{ +} + + +status_t +BPackageInfo::ReadFromConfigFile(const BEntry& packageInfoEntry, + ParseErrorListener* listener) +{ + status_t result = packageInfoEntry.InitCheck(); + if (result != B_OK) + return result; + + BFile file(&packageInfoEntry, B_READ_ONLY); + if ((result = file.InitCheck()) != B_OK) + return result; + + off_t size; + if ((result = file.GetSize(&size)) != B_OK) + return result; + + BString packageInfoString; + char* buffer = packageInfoString.LockBuffer(size); + if (buffer == NULL) + return B_NO_MEMORY; + + if ((result = file.Read(buffer, size)) < size) { + packageInfoString.UnlockBuffer(0); + return result >= 0 ? B_IO_ERROR : result; + } + + buffer[size] = '\0'; + packageInfoString.UnlockBuffer(size); + + return ReadFromConfigString(packageInfoString, listener); +} + + +status_t +BPackageInfo::ReadFromConfigString(const BString& packageInfoString, + ParseErrorListener* listener) +{ + MakeEmpty(); + + Parser parser(listener); + return parser.Parse(packageInfoString, this); +} + + +status_t +BPackageInfo::InitCheck() const +{ + // TODO + return B_OK; +} + + +const BString& +BPackageInfo::Name() const +{ + return fName; +} + + +const BString& +BPackageInfo::Summary() const +{ + return fSummary; +} + + +const BString& +BPackageInfo::Description() const +{ + return fDescription; +} + + +const BString& +BPackageInfo::Vendor() const +{ + return fVendor; +} + + +const BString& +BPackageInfo::Packager() const +{ + return fPackager; +} + + +BPackageArchitecture +BPackageInfo::Architecture() const +{ + return fArchitecture; +} + + +const BPackageVersion& +BPackageInfo::Version() const +{ + return fVersion; +} + + +const BObjectList& +BPackageInfo::Copyrights() const +{ + return fCopyrights; +} + + +const BObjectList& +BPackageInfo::Licenses() const +{ + return fLicenses; +} + + +const BObjectList& +BPackageInfo::Requirements() const +{ + return fRequirements; +} + + +const BObjectList& +BPackageInfo::Provisions() const +{ + return fProvisions; +} + + +void +BPackageInfo::SetName(const BString& name) +{ + fName = name; +} + + +void +BPackageInfo::SetSummary(const BString& summary) +{ + fSummary = summary; +} + + +void +BPackageInfo::SetDescription(const BString& description) +{ + fDescription = description; +} + + +void +BPackageInfo::SetVendor(const BString& vendor) +{ + fVendor = vendor; +} + + +void +BPackageInfo::SetPackager(const BString& packager) +{ + fPackager = packager; +} + + +void +BPackageInfo::SetVersion(const BPackageVersion& version) +{ + fVersion = version; +} + + +void +BPackageInfo::SetArchitecture(BPackageArchitecture architecture) +{ + fArchitecture = architecture; +} + + +void +BPackageInfo::ClearCopyrights() +{ + fCopyrights.MakeEmpty(); +} + + +status_t +BPackageInfo::AddCopyright(const BString& copyright) +{ + BString* newCopyright = new (std::nothrow) BString(copyright); + if (newCopyright == NULL) + return B_NO_MEMORY; + + return fCopyrights.AddItem(newCopyright) ? B_OK : B_ERROR; +} + + +status_t +BPackageInfo::RemoveCopyright(const BString& copyright) +{ + int32 count = fCopyrights.CountItems(); + for (int i = 0; i < count; ++i) { + if (fCopyrights.ItemAt(i)->Compare(copyright) == 0) { + delete fCopyrights.RemoveItemAt(i); + return B_OK; + } + } + + return B_NAME_NOT_FOUND; +} + + +void +BPackageInfo::ClearLicenses() +{ + fLicenses.MakeEmpty(); +} + + +status_t +BPackageInfo::AddLicense(const BString& license) +{ + BString* newLicense = new (std::nothrow) BString(license); + if (newLicense == NULL) + return B_NO_MEMORY; + + return fLicenses.AddItem(newLicense) ? B_OK : B_ERROR; +} + + +status_t +BPackageInfo::RemoveLicense(const BString& license) +{ + int32 count = fLicenses.CountItems(); + for (int i = 0; i < count; ++i) { + if (fLicenses.ItemAt(i)->Compare(license) == 0) { + delete fLicenses.RemoveItemAt(i); + return B_OK; + } + } + + return B_NAME_NOT_FOUND; +} + + +void +BPackageInfo::ClearRequirements() +{ + fRequirements.MakeEmpty(); +} + + +status_t +BPackageInfo::AddRequirement(const BPackageRequirement& requirement) +{ + BPackageRequirement* newRequirement + = new (std::nothrow) BPackageRequirement(requirement); + if (newRequirement == NULL) + return B_NO_MEMORY; + + return fRequirements.AddItem(newRequirement) ? B_OK : B_ERROR; +} + + +status_t +BPackageInfo::RemoveRequirement(const BPackageRequirement& requirement) +{ + int32 count = fRequirements.CountItems(); + for (int i = 0; i < count; ++i) { + if (fRequirements.ItemAt(i)->Compare(requirement)) { + delete fRequirements.RemoveItemAt(i); + return B_OK; + } + } + + return B_NAME_NOT_FOUND; +} + + +void +BPackageInfo::ClearProvisions() +{ + fProvisions.MakeEmpty(); +} + + +status_t +BPackageInfo::AddProvision(const BPackageProvision& provision) +{ + BPackageProvision* newProvision + = new (std::nothrow) BPackageProvision(provision); + if (newProvision == NULL) + return B_NO_MEMORY; + + return fProvisions.AddItem(newProvision) ? B_OK : B_ERROR; +} + + +status_t +BPackageInfo::RemoveProvision(const BPackageProvision& provision) +{ + int32 count = fProvisions.CountItems(); + for (int i = 0; i < count; ++i) { + if (fProvisions.ItemAt(i)->Compare(provision) == 0) { + delete fProvisions.RemoveItemAt(i); + return B_OK; + } + } + + return B_NAME_NOT_FOUND; +} + + +void +BPackageInfo::MakeEmpty() +{ + fName.Truncate(0); + fSummary.Truncate(0); + fDescription.Truncate(0); + fVendor.Truncate(0); + fPackager.Truncate(0); + fVersion.MakeEmpty(); + fArchitecture = B_PACKAGE_ARCHITECTURE_NONE; + fCopyrights.MakeEmpty(); + fLicenses.MakeEmpty(); + fRequirements.MakeEmpty(); + fProvisions.MakeEmpty(); +} + + +/*static*/ status_t +BPackageInfo::GetElementName(BPackageInfoIndex index, const char** name) +{ + if (index < 0 || index >= B_PACKAGE_INFO_ENUM_COUNT || name == NULL) + return B_BAD_VALUE; + + *name = kElementNames[index]; + + return B_OK; +} + + +} // namespace BPackageKit diff --git a/src/kits/package/RepositoryConfig.cpp b/src/kits/package/RepositoryConfig.cpp index 0d70369bb9..9fec8561fe 100644 --- a/src/kits/package/RepositoryConfig.cpp +++ b/src/kits/package/RepositoryConfig.cpp @@ -103,8 +103,10 @@ BRepositoryConfig::SetTo(const BEntry& entry) if (buffer == NULL) return B_NO_MEMORY; - if ((result = file.Read(buffer, size)) < size) + if ((result = file.Read(buffer, size)) < size) { + configString.UnlockBuffer(0); return (result >= 0) ? B_IO_ERROR : result; + } buffer[size] = '\0'; configString.UnlockBuffer(size); diff --git a/src/bin/package/BlockBufferCache.cpp b/src/kits/package/hpkg/BlockBufferCache.cpp similarity index 95% rename from src/bin/package/BlockBufferCache.cpp rename to src/kits/package/hpkg/BlockBufferCache.cpp index dca4d97cf2..fc8e9a4fd5 100644 --- a/src/bin/package/BlockBufferCache.cpp +++ b/src/kits/package/hpkg/BlockBufferCache.cpp @@ -4,7 +4,7 @@ */ -#include "BlockBufferCache.h" +#include #include #include @@ -12,6 +12,13 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + // #pragma mark - BlockBufferCache @@ -206,3 +213,10 @@ void BlockBufferCacheNoLock::Unlock() { } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/BufferCache.cpp b/src/kits/package/hpkg/BufferCache.cpp similarity index 67% rename from src/bin/package/BufferCache.cpp rename to src/kits/package/hpkg/BufferCache.cpp index e74aa30f01..6a77ee707e 100644 --- a/src/bin/package/BufferCache.cpp +++ b/src/kits/package/hpkg/BufferCache.cpp @@ -4,11 +4,18 @@ */ -#include "BufferCache.h" +#include #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + // #pragma mark - CachedBuffer @@ -34,3 +41,10 @@ CachedBuffer::~CachedBuffer() BufferCache::~BufferCache() { } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/DataOutput.cpp b/src/kits/package/hpkg/DataOutput.cpp similarity index 75% rename from src/bin/package/DataOutput.cpp rename to src/kits/package/hpkg/DataOutput.cpp index dc600c1bb4..03307c8670 100644 --- a/src/bin/package/DataOutput.cpp +++ b/src/kits/package/hpkg/DataOutput.cpp @@ -4,11 +4,18 @@ */ -#include "DataOutput.h" +#include #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + // #pragma mark - DataOutput @@ -42,3 +49,10 @@ BufferDataOutput::WriteData(const void* buffer, size_t size) return B_OK; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/DataReader.cpp b/src/kits/package/hpkg/DataReader.cpp similarity index 87% rename from src/bin/package/DataReader.cpp rename to src/kits/package/hpkg/DataReader.cpp index 735103d4fc..7425d154ff 100644 --- a/src/bin/package/DataReader.cpp +++ b/src/kits/package/hpkg/DataReader.cpp @@ -4,7 +4,7 @@ */ -#include "DataReader.h" +#include #include #include @@ -13,6 +13,13 @@ #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + // #pragma mark - DataReader @@ -91,3 +98,10 @@ BufferDataReader::ReadData(off_t offset, void* buffer, size_t size) memcpy(buffer, (const uint8*)fData + offset, size); return B_OK; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/ErrorOutput.cpp b/src/kits/package/hpkg/ErrorOutput.cpp similarity index 61% rename from src/bin/package/ErrorOutput.cpp rename to src/kits/package/hpkg/ErrorOutput.cpp index 7b0ce9c19d..0bcb98b268 100644 --- a/src/bin/package/ErrorOutput.cpp +++ b/src/kits/package/hpkg/ErrorOutput.cpp @@ -4,11 +4,18 @@ */ -#include "ErrorOutput.h" +#include #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + ErrorOutput::~ErrorOutput() { } @@ -22,3 +29,10 @@ ErrorOutput::PrintError(const char* format, ...) PrintErrorVarArgs(format, args); va_end(args); } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/PackageData.cpp b/src/kits/package/hpkg/PackageData.cpp similarity index 76% rename from src/bin/package/PackageData.cpp rename to src/kits/package/hpkg/PackageData.cpp index c724b6bde1..95e0d6aa70 100644 --- a/src/bin/package/PackageData.cpp +++ b/src/kits/package/hpkg/PackageData.cpp @@ -4,11 +4,18 @@ */ -#include "PackageData.h" +#include #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + PackageData::PackageData() : fCompressedSize(0), @@ -37,3 +44,10 @@ PackageData::SetData(uint8 size, const void* data) memcpy(fInlineData, data, size); fEncodedInline = true; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/PackageDataReader.cpp b/src/kits/package/hpkg/PackageDataReader.cpp similarity index 96% rename from src/bin/package/PackageDataReader.cpp rename to src/kits/package/hpkg/PackageDataReader.cpp index 8274f4d7d1..6875b04aac 100644 --- a/src/bin/package/PackageDataReader.cpp +++ b/src/kits/package/hpkg/PackageDataReader.cpp @@ -4,19 +4,25 @@ */ -#include "PackageDataReader.h" +#include #include #include #include -#include +#include +#include +#include +#include +#include -#include "BufferCache.h" -#include "DataOutput.h" -#include "PackageData.h" -#include "ZlibDecompressor.h" + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { // minimum/maximum zlib chunk size we consider sane @@ -449,3 +455,10 @@ PackageDataReaderFactory::CreatePackageDataReader(DataReader* dataReader, _reader = reader; return B_OK; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/PackageEntry.cpp b/src/kits/package/hpkg/PackageEntry.cpp similarity index 70% rename from src/bin/package/PackageEntry.cpp rename to src/kits/package/hpkg/PackageEntry.cpp index c609aba835..e573475c99 100644 --- a/src/bin/package/PackageEntry.cpp +++ b/src/kits/package/hpkg/PackageEntry.cpp @@ -4,7 +4,14 @@ */ -#include "PackageEntry.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { PackageEntry::PackageEntry(PackageEntry* parent, const char* name) @@ -22,3 +29,10 @@ PackageEntry::PackageEntry(PackageEntry* parent, const char* name) fCreationTime.tv_sec = 0; fCreationTime.tv_nsec = 0; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/PackageEntryAttribute.cpp b/src/kits/package/hpkg/PackageEntryAttribute.cpp similarity index 50% rename from src/bin/package/PackageEntryAttribute.cpp rename to src/kits/package/hpkg/PackageEntryAttribute.cpp index 27f5bd5d80..bdd1f3ec29 100644 --- a/src/bin/package/PackageEntryAttribute.cpp +++ b/src/kits/package/hpkg/PackageEntryAttribute.cpp @@ -4,7 +4,14 @@ */ -#include "PackageEntryAttribute.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { PackageEntryAttribute::PackageEntryAttribute(const char* name) @@ -13,3 +20,10 @@ PackageEntryAttribute::PackageEntryAttribute(const char* name) fType(0) { } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/PackageReader.cpp b/src/kits/package/hpkg/PackageReader.cpp similarity index 98% rename from src/bin/package/PackageReader.cpp rename to src/kits/package/hpkg/PackageReader.cpp index c9ee4e6345..d9b88e06e5 100644 --- a/src/bin/package/PackageReader.cpp +++ b/src/kits/package/hpkg/PackageReader.cpp @@ -4,7 +4,7 @@ */ -#include "PackageReader.h" +#include #include #include @@ -19,14 +19,21 @@ #include -#include +#include -#include "DataOutput.h" -#include "ErrorOutput.h" -#include "PackageData.h" -#include "PackageEntry.h" -#include "PackageEntryAttribute.h" -#include "ZlibDecompressor.h" +#include +#include +#include +#include +#include +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { //#define TRACE(format...) printf(format) @@ -1378,3 +1385,10 @@ PackageReader::_GetStandardIndex(const AttributeType* type) return -1; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/PackageWriter.cpp b/src/kits/package/hpkg/PackageWriter.cpp similarity index 98% rename from src/bin/package/PackageWriter.cpp rename to src/kits/package/hpkg/PackageWriter.cpp index 0ffc7e0a8a..b1f0ba8a60 100644 --- a/src/bin/package/PackageWriter.cpp +++ b/src/kits/package/hpkg/PackageWriter.cpp @@ -4,7 +4,7 @@ */ -#include "PackageWriter.h" +#include #include #include @@ -23,13 +23,20 @@ #include -#include +#include -#include "DataOutput.h" -#include "DataReader.h" -#include "FDCloser.h" -#include "Stacker.h" -#include "ZlibCompressor.h" +#include +#include +#include +#include +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { // minimum length of data we require before trying to zlib compress them @@ -1505,3 +1512,10 @@ PackageWriter::_WriteZlibCompressedData(DataReader& dataReader, off_t size, _compressedSize = writeOffset - offsetTableOffset; return B_OK; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/Strings.cpp b/src/kits/package/hpkg/Strings.cpp similarity index 66% rename from src/bin/package/Strings.cpp rename to src/kits/package/hpkg/Strings.cpp index 881d987f58..1fbb51a76e 100644 --- a/src/bin/package/Strings.cpp +++ b/src/kits/package/hpkg/Strings.cpp @@ -4,7 +4,14 @@ */ -#include "Strings.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { // from the Dragon Book: a slightly modified hashpjw() @@ -25,3 +32,10 @@ hash_string(const char* string) return h; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/compression/ZlibCompressionBase.cpp b/src/kits/package/hpkg/ZlibCompressionBase.cpp similarity index 77% rename from src/bin/package/compression/ZlibCompressionBase.cpp rename to src/kits/package/hpkg/ZlibCompressionBase.cpp index 879d11955f..22f29005c6 100644 --- a/src/bin/package/compression/ZlibCompressionBase.cpp +++ b/src/kits/package/hpkg/ZlibCompressionBase.cpp @@ -4,13 +4,20 @@ */ -#include "ZlibCompressionBase.h" +#include #include #include +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { + + /*static*/ status_t ZlibCompressionBase::TranslateZlibError(int error) { @@ -38,3 +45,10 @@ ZlibCompressionBase::TranslateZlibError(int error) return B_ERROR; } } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/compression/ZlibCompressor.cpp b/src/kits/package/hpkg/ZlibCompressor.cpp similarity index 93% rename from src/bin/package/compression/ZlibCompressor.cpp rename to src/kits/package/hpkg/ZlibCompressor.cpp index cd636e268f..8bc2821d26 100644 --- a/src/bin/package/compression/ZlibCompressor.cpp +++ b/src/kits/package/hpkg/ZlibCompressor.cpp @@ -4,12 +4,19 @@ */ -#include "ZlibCompressor.h" +#include #include #include -#include "DataOutput.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { static const size_t kOutputBufferSize = 1024; @@ -169,3 +176,10 @@ ZlibCompressor::CompressSingleBuffer(const void* input, size_t inputSize, _compressedSize = zStream.total_out; return B_OK; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit diff --git a/src/bin/package/compression/ZlibDecompressor.cpp b/src/kits/package/hpkg/ZlibDecompressor.cpp similarity index 93% rename from src/bin/package/compression/ZlibDecompressor.cpp rename to src/kits/package/hpkg/ZlibDecompressor.cpp index e6d944ba49..f092ae2e22 100644 --- a/src/bin/package/compression/ZlibDecompressor.cpp +++ b/src/kits/package/hpkg/ZlibDecompressor.cpp @@ -4,12 +4,19 @@ */ -#include "ZlibDecompressor.h" +#include #include #include -#include "DataOutput.h" +#include + + +namespace BPackageKit { + +namespace BHaikuPackage { + +namespace BPrivate { // TODO: For the kernel the buffer shouldn't be allocated on the stack. @@ -176,3 +183,10 @@ ZlibDecompressor::DecompressSingleBuffer(const void* input, size_t inputSize, _uncompressedSize = zStream.total_out; return B_OK; } + + +} // namespace BPrivate + +} // namespace BHaikuPackage + +} // namespace BPackageKit