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


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@40301 a95241bf-73f2-0310-859d-f6bbb57e9c96

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;
 

headers/os/package/PackageInfo.h

@@ -0,0 +1,183 @@
+/*
+ * Copyright 2011, Oliver Tappe <[email protected]>
+ * 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_

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 <Entry.h>
@@ -68,4 +68,4 @@ private:
 }	// namespace BPackageKit
 
 
-#endif // _PACKAGE__ROSTER_H_
+#endif // _PACKAGE__PACKAGE_ROSTER_H_

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 <package/hpkg/BufferCache.h>
+
+
+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_

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 <stddef.h>
@@ -11,6 +11,13 @@
 #include <util/DoublyLinkedList.h>
 
 
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
 class CachedBuffer : public DoublyLinkedListLinkImpl<CachedBuffer> {
 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_

headers/private/package/hpkg/DataOutput.h

@@ -9,6 +9,13 @@
 #include <SupportDefs.h>
 
 
+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

headers/private/package/hpkg/DataReader.h

@@ -9,6 +9,13 @@
 #include <SupportDefs.h>
 
 
+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

headers/private/package/hpkg/ErrorOutput.h

@@ -11,6 +11,13 @@
 #include <SupportDefs.h>
 
 
+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

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

headers/private/package/hpkg/PackageAttributeValue.h

@@ -8,7 +8,14 @@
 
 #include <string.h>
 
-#include <haiku_package.h>
+#include <package/hpkg/haiku_package.h>
+
+
+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

headers/private/package/hpkg/PackageData.h

@@ -6,7 +6,14 @@
 #define PACKAGE_DATA_H
 
 
-#include <haiku_package.h>
+#include <package/hpkg/haiku_package.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
 
 
 class PackageData {
@@ -49,4 +56,11 @@ private:
 };
 
 
+}	// namespace BPrivate
+
+}	// namespace BHaikuPackage
+
+}	// namespace BPackageKit
+
+
 #endif	// PACKAGE_DATA_H

headers/private/package/hpkg/PackageDataReader.h

@@ -6,7 +6,14 @@
 #define PACKAGE_DATA_READER_H
 
 
-#include "DataReader.h"
+#include <package/hpkg/DataReader.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
 
 
 class BufferCache;
@@ -48,4 +55,11 @@ private:
 };
 
 
+}	// namespace BPrivate
+
+}	// namespace BHaikuPackage
+
+}	// namespace BPackageKit
+
+
 #endif	// PACKAGE_DATA_READER_H

headers/private/package/hpkg/PackageEntry.h

@@ -8,7 +8,14 @@
 
 #include <sys/stat.h>
 
-#include "PackageData.h"
+#include <package/hpkg/PackageData.h>
+
+
+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

headers/private/package/hpkg/PackageEntryAttribute.h

@@ -6,7 +6,14 @@
 #define PACKAGE_ENTRY_ATTRIBUTE_H
 
 
-#include "PackageData.h"
+#include <package/hpkg/PackageData.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
 
 
 class PackageEntryAttribute {
@@ -27,4 +34,11 @@ private:
 };
 
 
+}	// namespace BPrivate
+
+}	// namespace BHaikuPackage
+
+}	// namespace BPackageKit
+
+
 #endif	// PACKAGE_ENTRY_ATTRIBUTE_H

headers/private/package/hpkg/PackageReader.h

@@ -10,7 +10,14 @@
 
 #include <util/SinglyLinkedList.h>
 
-#include "PackageAttributeValue.h"
+#include <package/hpkg/PackageAttributeValue.h>
+
+
+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

headers/private/package/hpkg/PackageWriter.h

@@ -9,12 +9,23 @@
 #include <util/DoublyLinkedList.h>
 #include <util/OpenHashTable.h>
 
-#include "Strings.h"
+#include <package/hpkg/Strings.h>
+
+
+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

headers/private/package/hpkg/Stacker.h

@@ -6,6 +6,13 @@
 #define STACKER_H
 
 
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
 template<typename Type>
 class Stacker {
 public:
@@ -37,4 +44,11 @@ private:
 };
 
 
+}	// namespace BPrivate
+
+}	// namespace BHaikuPackage
+
+}	// namespace BPackageKit
+
+
 #endif	// STACKER_H

headers/private/package/hpkg/Strings.h

@@ -9,6 +9,13 @@
 #include <util/OpenHashTable.h>
 
 
+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

headers/private/package/hpkg/ZlibCompressionBase.h

@@ -9,10 +9,24 @@
 #include <SupportDefs.h>
 
 
+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

headers/private/package/hpkg/ZlibCompressor.h

@@ -8,7 +8,14 @@
 
 #include <zlib.h>
 
-#include "ZlibCompressionBase.h"
+#include <package/hpkg/ZlibCompressionBase.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
 
 
 class DataOutput;
@@ -35,4 +42,11 @@ private:
 };
 
 
+}	// namespace BPrivate
+
+}	// namespace BHaikuPackage
+
+}	// namespace BPackageKit
+
+
 #endif	// ZLIB_COMPRESSOR_H

headers/private/package/hpkg/ZlibDecompressor.h

@@ -8,7 +8,14 @@
 
 #include <zlib.h>
 
-#include "ZlibCompressionBase.h"
+#include <package/hpkg/ZlibCompressionBase.h>
+
+
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
 
 
 class DataOutput;
@@ -37,4 +44,11 @@ private:
 };
 
 
+}	// namespace BPrivate
+
+}	// namespace BHaikuPackage
+
+}	// namespace BPackageKit
+
+
 #endif	// ZLIB_DECOMPRESSOR_H

headers/private/package/hpkg/haiku_package.h

@@ -9,6 +9,13 @@
 #include <SupportDefs.h>
 
 
+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

src/add-ons/kernel/file_systems/packagefs/BlockBufferCacheKernel.h

@@ -8,7 +8,10 @@
 
 #include <util/AutoLock.h>
 
-#include "BlockBufferCache.h"
+#include <package/hpkg/BlockBufferCache.h>
+
+
+using BPackageKit::BHaikuPackage::BPrivate::BlockBufferCache;
 
 
 class BlockBufferCacheKernel : public BlockBufferCache {

src/add-ons/kernel/file_systems/packagefs/GlobalFactory.cpp

@@ -8,7 +8,7 @@
 
 #include <new>
 
-#include <haiku_package.h>
+#include <package/hpkg/haiku_package.h>
 
 
 static const uint32 kMaxCachedBuffers = 32;

src/add-ons/kernel/file_systems/packagefs/GlobalFactory.h

@@ -6,8 +6,13 @@
 #define GLOBAL_FACTORY_H
 
 
+#include <package/hpkg/haiku_package.h>
+#include <package/hpkg/PackageDataReader.h>
+
 #include "BlockBufferCacheKernel.h"
-#include "PackageDataReader.h"
+
+
+using namespace BPackageKit::BHaikuPackage::BPrivate;
 
 
 class GlobalFactory {

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

src/add-ons/kernel/file_systems/packagefs/PackageFile.cpp

@@ -11,15 +11,18 @@
 
 #include <fs_cache.h>
 
-#include "DataOutput.h"
-#include "DataReader.h"
-#include "PackageDataReader.h"
+#include <package/hpkg/DataOutput.h>
+#include <package/hpkg/DataReader.h>
+#include <package/hpkg/PackageDataReader.h>
 
 #include "DebugSupport.h"
 #include "GlobalFactory.h"
 #include "Package.h"
 
 
+using namespace BPackageKit::BHaikuPackage::BPrivate;
+
+
 // #pragma mark - DataAccessor
 
 

src/add-ons/kernel/file_systems/packagefs/PackageFile.h

@@ -6,11 +6,14 @@
 #define PACKAGE_FILE_H
 
 
-#include "PackageData.h"
+#include <package/hpkg/PackageData.h>
 
 #include "PackageLeafNode.h"
 
 
+using BPackageKit::BHaikuPackage::BPrivate::PackageData;
+
+
 class PackageFile : public PackageLeafNode {
 public:
 								PackageFile(Package* package, mode_t mode,

src/add-ons/kernel/file_systems/packagefs/PackageNodeAttribute.h

@@ -8,9 +8,11 @@
 
 #include <util/DoublyLinkedList.h>
 
-#include "PackageData.h"
+#include <package/hpkg/PackageData.h>
 
 
+using BPackageKit::BHaikuPackage::BPrivate::PackageData;
+
 class PackageNode;
 
 

src/add-ons/kernel/file_systems/packagefs/Volume.cpp

@@ -23,11 +23,11 @@
 
 #include <Notifications.h>
 
-#include "ErrorOutput.h"
-#include "FDCloser.h"
-#include "PackageEntry.h"
-#include "PackageEntryAttribute.h"
-#include "PackageReader.h"
+#include <package/hpkg/ErrorOutput.h>
+#include <package/hpkg/FDCloser.h>
+#include <package/hpkg/PackageEntry.h>
+#include <package/hpkg/PackageEntryAttribute.h>
+#include <package/hpkg/PackageReader.h>
 
 #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;

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++)
 ;

src/bin/package/StandardErrorOutput.h

@@ -6,7 +6,10 @@
 #define STANDARD_ERROR_OUTPUT_H
 
 
-#include "ErrorOutput.h"
+#include <package/hpkg/ErrorOutput.h>
+
+
+using BPackageKit::BHaikuPackage::BPrivate::ErrorOutput;
 
 
 class StandardErrorOutput : public ErrorOutput {

src/bin/package/command_create.cpp

@@ -4,8 +4,6 @@
  */
 
 
-#include "package.h"
-
 #include <dirent.h>
 #include <errno.h>
 #include <getopt.h>
@@ -13,8 +11,17 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <Entry.h>
+
+#include <package/PackageInfo.h>
+#include <package/hpkg/haiku_package.h>
+#include <package/hpkg/PackageWriter.h>
+
 #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)

src/bin/package/command_dump.cpp

@@ -4,8 +4,6 @@
  */
 
 
-#include "package.h"
-
 #include <ctype.h>
 #include <errno.h>
 #include <getopt.h>
@@ -13,13 +11,17 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <package/hpkg/PackageEntry.h>
+#include <package/hpkg/PackageEntryAttribute.h>
+#include <package/hpkg/PackageReader.h>
+
 #include "package.h"
-#include "PackageEntry.h"
-#include "PackageEntryAttribute.h"
-#include "PackageReader.h"
 #include "StandardErrorOutput.h"
 
 
+using namespace BPackageKit::BHaikuPackage::BPrivate;
+
+
 struct PackageContentDumpHandler : LowLevelPackageContentHandler {
 	PackageContentDumpHandler()
 		:

src/bin/package/command_extract.cpp

@@ -4,8 +4,6 @@
  */
 
 
-#include "package.h"
-
 #include <ctype.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -23,16 +21,20 @@
 
 #include <AutoDeleter.h>
 
-#include "BlockBufferCache.h"
-#include "FDCloser.h"
+#include <package/hpkg/BlockBufferCache.h>
+#include <package/hpkg/FDCloser.h>
+#include <package/hpkg/PackageDataReader.h>
+#include <package/hpkg/PackageEntry.h>
+#include <package/hpkg/PackageEntryAttribute.h>
+#include <package/hpkg/PackageReader.h>
+
 #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)
 		:

src/bin/package/command_list.cpp

@@ -4,8 +4,6 @@
  */
 
 
-#include "package.h"
-
 #include <ctype.h>
 #include <errno.h>
 #include <getopt.h>
@@ -13,13 +11,17 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <package/hpkg/PackageEntry.h>
+#include <package/hpkg/PackageEntryAttribute.h>
+#include <package/hpkg/PackageReader.h>
+
 #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)
 		:

src/bin/package/package.cpp

@@ -12,7 +12,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "PackageWriter.h"
+#include <package/hpkg/PackageWriter.h>
 
 
 extern const char* __progname;

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";
 

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++)
 ;

src/kits/package/PackageInfo.cpp

@@ -0,0 +1,880 @@
+#include <stdio.h>
+/*
+ * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include <package/PackageInfo.h>
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <new>
+
+#include <File.h>
+#include <Entry.h>
+#include <String.h>
+
+
+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<BString> copyrights;
+//			_ParseStringList(&copyrights);
+//			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<BString> 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<BPackageProvision> 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<BPackageRequirement> 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<BString>&
+BPackageInfo::Copyrights() const
+{
+	return fCopyrights;
+}
+
+
+const BObjectList<BString>&
+BPackageInfo::Licenses() const
+{
+	return fLicenses;
+}
+
+
+const BObjectList<BPackageRequirement>&
+BPackageInfo::Requirements() const
+{
+	return fRequirements;
+}
+
+
+const BObjectList<BPackageProvision>&
+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

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);

src/kits/package/hpkg/BlockBufferCache.cpp

@@ -4,7 +4,7 @@
  */
 
 
-#include "BlockBufferCache.h"
+#include <package/hpkg/BlockBufferCache.h>
 
 #include <algorithm>
 #include <new>
@@ -12,6 +12,13 @@
 #include <AutoLocker.h>
 
 
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
 // #pragma mark - BlockBufferCache
 
 
@@ -206,3 +213,10 @@ void
 BlockBufferCacheNoLock::Unlock()
 {
 }
+
+
+}	// namespace BPrivate
+
+}	// namespace BHaikuPackage
+
+}	// namespace BPackageKit

src/kits/package/hpkg/BufferCache.cpp

@@ -4,11 +4,18 @@
  */
 
 
-#include "BufferCache.h"
+#include <package/hpkg/BufferCache.h>
 
 #include <stdlib.h>
 
 
+namespace BPackageKit {
+
+namespace BHaikuPackage {
+
+namespace BPrivate {
+
+
 // #pragma mark - CachedBuffer
 
 
@@ -34,3 +41,10 @@ CachedBuffer::~CachedBuffer()
 BufferCache::~BufferCache()
 {
 }
+
+
+}	// namespace BPrivate
+
+}	// namespace BHaikuPackage
+
+}	// namespace BPackageKit

src/kits/package/hpkg/DataOutput.cpp

@@ -4,11 +4,18 @@
  */
 
 
-#include "DataOutput.h"
+#include <package/hpkg/DataOutput.h>
 
 #include <string.h>
 
 
+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

src/kits/package/hpkg/DataReader.cpp

@@ -4,7 +4,7 @@
  */
 
 
-#include "DataReader.h"
+#include <package/hpkg/DataReader.h>
 
 #include <errno.h>
 #include <string.h>
@@ -13,6 +13,13 @@
 #include <fs_attr.h>
 
 
+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

src/kits/package/hpkg/ErrorOutput.cpp

@@ -4,11 +4,18 @@
  */
 
 
-#include "ErrorOutput.h"
+#include <package/hpkg/ErrorOutput.h>
 
 #include <stdio.h>
 
 
+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

src/kits/package/hpkg/PackageData.cpp

@@ -4,11 +4,18 @@
  */
 
 
-#include "PackageData.h"
+#include <package/hpkg/PackageData.h>
 
 #include <string.h>
 
 
+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

src/kits/package/hpkg/PackageDataReader.cpp

@@ -4,19 +4,25 @@
  */
 
 
-#include "PackageDataReader.h"
+#include <package/hpkg/PackageDataReader.h>
 
 #include <string.h>
 
 #include <algorithm>
 #include <new>
 
-#include <haiku_package.h>
+#include <package/hpkg/haiku_package.h>
+#include <package/hpkg/BufferCache.h>
+#include <package/hpkg/DataOutput.h>
+#include <package/hpkg/PackageData.h>
+#include <package/hpkg/ZlibDecompressor.h>
 
-#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

src/kits/package/hpkg/PackageEntry.cpp

@@ -4,7 +4,14 @@
  */
 
 
-#include "PackageEntry.h"
+#include <package/hpkg/PackageEntry.h>
+
+
+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

src/kits/package/hpkg/PackageEntryAttribute.cpp

@@ -4,7 +4,14 @@
  */
 
 
-#include "PackageEntryAttribute.h"
+#include <package/hpkg/PackageEntryAttribute.h>
+
+
+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

src/kits/package/hpkg/PackageReader.cpp

@@ -4,7 +4,7 @@
  */
 
 
-#include "PackageReader.h"
+#include <package/hpkg/PackageReader.h>
 
 #include <errno.h>
 #include <fcntl.h>
@@ -19,14 +19,21 @@
 
 #include <ByteOrder.h>
 
-#include <haiku_package.h>
+#include <package/hpkg/haiku_package.h>
 
-#include "DataOutput.h"
-#include "ErrorOutput.h"
-#include "PackageData.h"
-#include "PackageEntry.h"
-#include "PackageEntryAttribute.h"
-#include "ZlibDecompressor.h"
+#include <package/hpkg/DataOutput.h>
+#include <package/hpkg/ErrorOutput.h>
+#include <package/hpkg/PackageData.h>
+#include <package/hpkg/PackageEntry.h>
+#include <package/hpkg/PackageEntryAttribute.h>
+#include <package/hpkg/ZlibDecompressor.h>
+
+
+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

src/kits/package/hpkg/PackageWriter.cpp

@@ -4,7 +4,7 @@
  */
 
 
-#include "PackageWriter.h"
+#include <package/hpkg/PackageWriter.h>
 
 #include <dirent.h>
 #include <errno.h>
@@ -23,13 +23,20 @@
 
 #include <AutoDeleter.h>
 
-#include <haiku_package.h>
+#include <package/hpkg/haiku_package.h>
 
-#include "DataOutput.h"
-#include "DataReader.h"
-#include "FDCloser.h"
-#include "Stacker.h"
-#include "ZlibCompressor.h"
+#include <package/hpkg/DataOutput.h>
+#include <package/hpkg/DataReader.h>
+#include <package/hpkg/FDCloser.h>
+#include <package/hpkg/Stacker.h>
+#include <package/hpkg/ZlibCompressor.h>
+
+
+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

src/kits/package/hpkg/Strings.cpp

@@ -4,7 +4,14 @@
  */
 
 
-#include "Strings.h"
+#include <package/hpkg/Strings.h>
+
+
+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

src/kits/package/hpkg/ZlibCompressionBase.cpp

@@ -4,13 +4,20 @@
  */
 
 
-#include "ZlibCompressionBase.h"
+#include <package/hpkg/ZlibCompressionBase.h>
 
 #include <errno.h>
 
 #include <zlib.h>
 
 
+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

src/kits/package/hpkg/ZlibCompressor.cpp

@@ -4,12 +4,19 @@
  */
 
 
-#include "ZlibCompressor.h"
+#include <package/hpkg/ZlibCompressor.h>
 
 #include <errno.h>
 #include <stdio.h>
 
-#include "DataOutput.h"
+#include <package/hpkg/DataOutput.h>
+
+
+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

src/kits/package/hpkg/ZlibDecompressor.cpp

@@ -4,12 +4,19 @@
  */
 
 
-#include "ZlibDecompressor.h"
+#include <package/hpkg/ZlibDecompressor.h>
 
 #include <errno.h>
 #include <stdio.h>
 
-#include "DataOutput.h"
+#include <package/hpkg/DataOutput.h>
+
+
+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