Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

packagefs: Remove support for HPKGv1.

Browse Source 
The current version is "v2", and it has been since the final PM branch
was merged back in 2013, so it's unclear if anyone actually uses this
file format. The "package" command can still of course read these
files, it's just that packagefs will now not be able to.

It's very unlikely anyone is impacted by this change.
This commit is contained in:
Augustin Cavalier 2019-04-01 13:58:30 -04:00
parent f10ebdb1f7
commit d1a0bc4fb5
6 changed files with 3 additions and 488 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/add-ons/kernel/file_systems/packagefs/Jamfile
View File

@ -40,7 +40,6 @@ HAIKU_PACKAGE_FS_SOURCES =
Dependency.cpp
Directory.cpp
EmptyAttributeDirectoryCookie.cpp
GlobalFactory.cpp
Index.cpp
IndexedAttributeOwner.cpp
kernel_interface.cpp
@ -103,17 +102,6 @@ HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES =
ReaderImplBase.cpp
;
HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES_V1 =
HPKGDefsV1.cpp
PackageContentHandlerV1.cpp
PackageDataV1.cpp
PackageDataReaderV1.cpp
PackageEntryV1.cpp
PackageEntryAttributeV1.cpp
PackageReaderImplV1.cpp
ReaderImplBaseV1.cpp
;
Includes [ FGristFiles ZlibCompressionAlgorithm.cpp ]
: [ BuildFeatureAttribute zlib : headers ] ;
@ -136,7 +124,6 @@ KernelAddon packagefs
$(HAIKU_PACKAGE_FS_SOURCES)
$(HAIKU_PACKAGE_FS_SHARED_SOURCES)
$(HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES)
$(HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES_V1)
$(libSharedSources)
$(storageKitSources)
$(supportKitSources)
@ -149,8 +136,6 @@ SEARCH on [ FGristFiles $(HAIKU_PACKAGE_FS_SHARED_SOURCES) ]
+= [ FDirName $(HAIKU_TOP) src add-ons kernel file_systems shared ] ;
SEARCH on [ FGristFiles $(HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES) ]
+= [ FDirName $(HAIKU_TOP) src kits package hpkg ] ;
SEARCH on [ FGristFiles $(HAIKU_PACKAGE_FS_PACKAGE_READER_SOURCES_V1) ]
+= [ FDirName $(HAIKU_TOP) src kits package hpkg v1 ] ;
SEARCH on [ FGristFiles $(libSharedSources) ]
+= [ FDirName $(HAIKU_TOP) src build libshared ] ;
SEARCH on [ FGristFiles $(storageKitSources) ]

12
src/add-ons/kernel/file_systems/packagefs/kernel_interface.cpp
View File

@ -21,7 +21,6 @@
#include "AttributeDirectoryCookie.h"
#include "DebugSupport.h"
#include "Directory.h"
#include "GlobalFactory.h"
#include "Query.h"
#include "PackageFSRoot.h"
#include "StringConstants.h"
@ -1076,19 +1075,9 @@ packagefs_std_ops(int32 op, ...)
return error;
}
error = GlobalFactory::CreateDefault();
if (error != B_OK) {
ERROR("Failed to init GlobalFactory\n");
StringConstants::Cleanup();
StringPool::Cleanup();
exit_debugging();
return error;
}
error = PackageFSRoot::GlobalInit();
if (error != B_OK) {
ERROR("Failed to init PackageFSRoot\n");
GlobalFactory::DeleteDefault();
StringConstants::Cleanup();
StringPool::Cleanup();
exit_debugging();
@ -1102,7 +1091,6 @@ packagefs_std_ops(int32 op, ...)
{
PRINT("package_std_ops(): B_MODULE_UNINIT\n");
PackageFSRoot::GlobalUninit();
GlobalFactory::DeleteDefault();
StringConstants::Cleanup();
StringPool::Cleanup();
exit_debugging();

2
src/add-ons/kernel/file_systems/packagefs/nodes/UnpackingAttributeCookie.cpp
View File

@ -18,11 +18,11 @@
#include "AttributeIndexer.h"
#include "AutoPackageAttributes.h"
#include "DebugSupport.h"
#include "GlobalFactory.h"
#include "Package.h"
#include "PackageNode.h"
using BPackageKit::BHPKG::BDataReader;
using BPackageKit::BHPKG::BBufferDataReader;
using BPackageKit::BHPKG::BFDDataReader;

88
src/add-ons/kernel/file_systems/packagefs/package/GlobalFactory.cpp
View File

@ -1,88 +0,0 @@
/*
* Copyright 2009-2013, Ingo Weinhold, ingo_weinhold@gmx.de.
* Distributed under the terms of the MIT License.
*/
#include "GlobalFactory.h"
#include <new>
#include <package/hpkg/HPKGDefs.h>
#include "PackageData.h"
static const uint32 kMaxCachedBuffers = 32;
/*static*/ GlobalFactory* GlobalFactory::sDefaultInstance = NULL;
GlobalFactory::GlobalFactory()
:
fBufferPool(BPackageKit::BHPKG::V1::B_HPKG_DEFAULT_DATA_CHUNK_SIZE_ZLIB,
kMaxCachedBuffers),
fPackageDataReaderFactory(&fBufferPool)
{
}
GlobalFactory::~GlobalFactory()
{
}
/*static*/ status_t
GlobalFactory::CreateDefault()
{
if (sDefaultInstance != NULL)
return B_OK;
GlobalFactory* factory = new(std::nothrow) GlobalFactory;
if (factory == NULL)
return B_NO_MEMORY;
status_t error = factory->_Init();
if (error != B_OK) {
delete factory;
return error;
}
sDefaultInstance = factory;
return B_OK;
}
/*static*/ void
GlobalFactory::DeleteDefault()
{
delete sDefaultInstance;
sDefaultInstance = NULL;
}
/*static*/ GlobalFactory*
GlobalFactory::Default()
{
return sDefaultInstance;
}
status_t
GlobalFactory::CreatePackageDataReader(BDataReader* dataReader,
const PackageDataV1& data, BAbstractBufferedDataReader*& _reader)
{
return fPackageDataReaderFactory.CreatePackageDataReader(dataReader, data,
_reader);
}
status_t
GlobalFactory::_Init()
{
status_t error = fBufferPool.Init();
if (error != B_OK)
return error;
return B_OK;
}

48
src/add-ons/kernel/file_systems/packagefs/package/GlobalFactory.h
View File

@ -1,48 +0,0 @@
/*
* Copyright 2009-2013, Ingo Weinhold, ingo_weinhold@gmx.de.
* Distributed under the terms of the MIT License.
*/
#ifndef GLOBAL_FACTORY_H
#define GLOBAL_FACTORY_H
#include <package/hpkg/v1/PackageDataReader.h>
#include "BlockBufferPoolKernel.h"
#include "PackageData.h"
using BPackageKit::BHPKG::BBufferPool;
using BPackageKit::BHPKG::BDataReader;
using BPackageKit::BHPKG::BPackageData;
using BPackageKit::BHPKG::BAbstractBufferedDataReader;
typedef BPackageKit::BHPKG::V1::BPackageDataReaderFactory
BPackageDataReaderFactoryV1;
class GlobalFactory {
private:
GlobalFactory();
~GlobalFactory();
public:
static status_t CreateDefault();
static void DeleteDefault();
static GlobalFactory* Default();
status_t CreatePackageDataReader(BDataReader* dataReader,
const PackageDataV1& data,
BAbstractBufferedDataReader*& _reader);
private:
status_t _Init();
private:
static GlobalFactory* sDefaultInstance;
BlockBufferPoolKernel fBufferPool;
BPackageDataReaderFactoryV1 fPackageDataReaderFactory;
};
#endif // GLOBAL_FACTORY_H

326
src/add-ons/kernel/file_systems/packagefs/package/Package.cpp
View File

@ -16,19 +16,15 @@
#include <package/hpkg/PackageDataReader.h>
#include <package/hpkg/PackageEntry.h>
#include <package/hpkg/PackageEntryAttribute.h>
#include <package/hpkg/v1/PackageEntry.h>
#include <package/hpkg/v1/PackageEntryAttribute.h>
#include <AutoDeleter.h>
#include <FdIO.h>
#include <package/hpkg/PackageFileHeapReader.h>
#include <package/hpkg/PackageReaderImpl.h>
#include <package/hpkg/v1/PackageReaderImpl.h>
#include <util/AutoLock.h>
#include "CachedDataReader.h"
#include "DebugSupport.h"
#include "GlobalFactory.h"
#include "PackageDirectory.h"
#include "PackageFile.h"
#include "PackagesDirectory.h"
@ -52,12 +48,6 @@ typedef BPackageKit::BHPKG::BPackageEntry BPackageEntry;
typedef BPackageKit::BHPKG::BPackageEntryAttribute BPackageEntryAttribute;
typedef BPackageKit::BHPKG::BPrivate::PackageReaderImpl PackageReaderImpl;
// format version V1 types
typedef BPackageKit::BHPKG::V1::BPackageContentHandler BPackageContentHandlerV1;
typedef BPackageKit::BHPKG::V1::BPackageEntry BPackageEntryV1;
typedef BPackageKit::BHPKG::V1::BPackageEntryAttribute BPackageEntryAttributeV1;
typedef BPackageKit::BHPKG::V1::BPrivate::PackageReaderImpl PackageReaderImplV1;
const char* const kArchitectureNames[B_PACKAGE_ARCHITECTURE_ENUM_COUNT] = {
"any",
@ -384,258 +374,6 @@ private:
};
// #pragma mark - LoaderContentHandlerV1
struct Package::LoaderContentHandlerV1 : BPackageContentHandlerV1 {
LoaderContentHandlerV1(Package* package)
:
fPackage(package),
fErrorOccurred(false)
{
}
status_t Init()
{
return B_OK;
}
virtual status_t HandleEntry(BPackageEntryV1* entry)
{
if (fErrorOccurred)
return B_OK;
PackageDirectory* parentDir = NULL;
if (entry->Parent() != NULL) {
parentDir = dynamic_cast<PackageDirectory*>(
(PackageNode*)entry->Parent()->UserToken());
if (parentDir == NULL)
RETURN_ERROR(B_BAD_DATA);
}
// get the file mode -- filter out write permissions
mode_t mode = entry->Mode() & ~(mode_t)(S_IWUSR | S_IWGRP | S_IWOTH);
// create the package node
PackageNode* node;
if (S_ISREG(mode)) {
// file
node = new(std::nothrow) PackageFile(fPackage, mode,
PackageData(entry->Data()));
} else if (S_ISLNK(mode)) {
// symlink
String path;
if (!path.SetTo(entry->SymlinkPath()))
RETURN_ERROR(B_NO_MEMORY);
PackageSymlink* symlink = new(std::nothrow) PackageSymlink(
fPackage, mode);
if (symlink == NULL)
RETURN_ERROR(B_NO_MEMORY);
symlink->SetSymlinkPath(path);
node = symlink;
} else if (S_ISDIR(mode)) {
// directory
node = new(std::nothrow) PackageDirectory(fPackage, mode);
} else
RETURN_ERROR(B_BAD_DATA);
if (node == NULL)
RETURN_ERROR(B_NO_MEMORY);
BReference<PackageNode> nodeReference(node, true);
String entryName;
if (!entryName.SetTo(entry->Name()))
RETURN_ERROR(B_NO_MEMORY);
status_t error = node->Init(parentDir, entryName);
if (error != B_OK)
RETURN_ERROR(error);
node->SetModifiedTime(entry->ModifiedTime());
// add it to the parent directory
if (parentDir != NULL)
parentDir->AddChild(node);
else
fPackage->AddNode(node);
entry->SetUserToken(node);
return B_OK;
}
virtual status_t HandleEntryAttribute(BPackageEntryV1* entry,
BPackageEntryAttributeV1* attribute)
{
if (fErrorOccurred)
return B_OK;
PackageNode* node = (PackageNode*)entry->UserToken();
String name;
if (!name.SetTo(attribute->Name()))
RETURN_ERROR(B_NO_MEMORY);
PackageNodeAttribute* nodeAttribute = new(std::nothrow)
PackageNodeAttribute(attribute->Type(),
PackageData(attribute->Data()));
if (nodeAttribute == NULL)
RETURN_ERROR(B_NO_MEMORY)
nodeAttribute->Init(name);
node->AddAttribute(nodeAttribute);
return B_OK;
}
virtual status_t HandleEntryDone(BPackageEntryV1* entry)
{
return B_OK;
}
virtual status_t HandlePackageAttribute(
const BPackageInfoAttributeValue& value)
{
switch (value.attributeID) {
case B_PACKAGE_INFO_NAME:
{
String name;
if (!name.SetTo(value.string))
return B_NO_MEMORY;
fPackage->SetName(name);
return B_OK;
}
case B_PACKAGE_INFO_INSTALL_PATH:
{
String path;
if (!path.SetTo(value.string))
return B_NO_MEMORY;
fPackage->SetInstallPath(path);
return B_OK;
}
case B_PACKAGE_INFO_VERSION:
{
::Version* version;
status_t error = Version::Create(value.version.major,
value.version.minor, value.version.micro,
value.version.preRelease, value.version.revision, version);
if (error != B_OK)
RETURN_ERROR(error);
fPackage->SetVersion(version);
break;
}
case B_PACKAGE_INFO_ARCHITECTURE:
if (value.unsignedInt >= B_PACKAGE_ARCHITECTURE_ENUM_COUNT)
RETURN_ERROR(B_BAD_VALUE);
fPackage->SetArchitecture(
(BPackageArchitecture)value.unsignedInt);
break;
case B_PACKAGE_INFO_PROVIDES:
{
// create a version object, if a version is specified
::Version* version = NULL;
if (value.resolvable.haveVersion) {
const BPackageVersionData& versionInfo
= value.resolvable.version;
status_t error = Version::Create(versionInfo.major,
versionInfo.minor, versionInfo.micro,
versionInfo.preRelease, versionInfo.revision, version);
if (error != B_OK)
RETURN_ERROR(error);
}
ObjectDeleter< ::Version> versionDeleter(version);
// create a version object, if a compatible version is specified
::Version* compatibleVersion = NULL;
if (value.resolvable.haveCompatibleVersion) {
const BPackageVersionData& versionInfo
= value.resolvable.compatibleVersion;
status_t error = Version::Create(versionInfo.major,
versionInfo.minor, versionInfo.micro,
versionInfo.preRelease, versionInfo.revision,
compatibleVersion);
if (error != B_OK)
RETURN_ERROR(error);
}
ObjectDeleter< ::Version> compatibleVersionDeleter(
compatibleVersion);
// create the resolvable
Resolvable* resolvable = new(std::nothrow) Resolvable(fPackage);
if (resolvable == NULL)
RETURN_ERROR(B_NO_MEMORY);
ObjectDeleter<Resolvable> resolvableDeleter(resolvable);
status_t error = resolvable->Init(value.resolvable.name,
versionDeleter.Detach(), compatibleVersionDeleter.Detach());
if (error != B_OK)
RETURN_ERROR(error);
fPackage->AddResolvable(resolvableDeleter.Detach());
break;
}
case B_PACKAGE_INFO_REQUIRES:
{
// create the dependency
Dependency* dependency = new(std::nothrow) Dependency(fPackage);
if (dependency == NULL)
RETURN_ERROR(B_NO_MEMORY);
ObjectDeleter<Dependency> dependencyDeleter(dependency);
status_t error = dependency->Init(
value.resolvableExpression.name);
if (error != B_OK)
RETURN_ERROR(error);
// create a version object, if a version is specified
::Version* version = NULL;
if (value.resolvableExpression.haveOpAndVersion) {
const BPackageVersionData& versionInfo
= value.resolvableExpression.version;
status_t error = Version::Create(versionInfo.major,
versionInfo.minor, versionInfo.micro,
versionInfo.preRelease, versionInfo.revision, version);
if (error != B_OK)
RETURN_ERROR(error);
dependency->SetVersionRequirement(
value.resolvableExpression.op, version);
}
fPackage->AddDependency(dependencyDeleter.Detach());
break;
}
default:
break;
}
return B_OK;
}
virtual void HandleErrorOccurred()
{
fErrorOccurred = true;
}
private:
Package* fPackage;
bool fErrorOccurred;
};
// #pragma mark - HeapReader
@ -651,46 +389,6 @@ struct Package::HeapReader {
};
// #pragma mark - HeapReaderV1
struct Package::HeapReaderV1 : public HeapReader, private BDataReader {
public:
HeapReaderV1(int fd)
:
fFileReader(fd)
{
}
~HeapReaderV1()
{
}
virtual void UpdateFD(int fd)
{
fFileReader.SetFD(fd);
}
virtual status_t CreateDataReader(const PackageData& data,
BAbstractBufferedDataReader*& _reader)
{
return GlobalFactory::Default()->CreatePackageDataReader(this,
data.DataV1(), _reader);
}
private:
// BDataReader
virtual status_t ReadData(off_t offset, void* buffer, size_t size)
{
return fFileReader.ReadData(offset, buffer, size);
}
private:
BFDDataReader fFileReader;
};
// #pragma mark - HeapReaderV2
@ -1050,28 +748,8 @@ Package::_Load(const PackageSettings& settings)
RETURN_ERROR(error);
}
// try package file format version 1
PackageReaderImplV1 packageReader(&errorOutput);
status_t error = packageReader.Init(fd, false);
if (error != B_OK)
RETURN_ERROR(error);
// parse content
LoaderContentHandlerV1 handler(this);
error = handler.Init();
if (error != B_OK)
RETURN_ERROR(error);
error = packageReader.ParseContent(&handler);
if (error != B_OK)
RETURN_ERROR(error);
// create a heap reader
fHeapReader = new(std::nothrow) HeapReaderV1(fd);
if (fHeapReader == NULL)
RETURN_ERROR(B_NO_MEMORY);
return B_OK;
// we don't support this package file format
RETURN_ERROR(B_BAD_DATA);
}