/*! This method recursively iterates through the descendents of the given
package root node and adds all package nodes to the node tree in
pre-order.
Due to limited kernel stack space we avoid deep recursive function calls
and rather use the package node stack implied by the tree.
*/
status_t
Volume::_AddPackageContentRootNode(Package* package,
PackageNode* rootPackageNode, bool notify)
{
PackageNode* packageNode = rootPackageNode;
Directory* directory = fRootDirectory;
directory->WriteLock();
do {
Node* node;
status_t error = _AddPackageNode(directory, packageNode, notify, node);
// returns B_OK with a NULL node, when skipping the node
if (error != B_OK) {
// unlock all directories
while (directory != NULL) {
directory->WriteUnlock();
directory = directory->Parent();
}
// remove the added package nodes
_RemovePackageContentRootNode(package, rootPackageNode, packageNode,
notify);
RETURN_ERROR(error);
}
// recurse into directory, unless we're supposed to skip the node
if (node != NULL) {
if (PackageDirectory* packageDirectory
= dynamic_cast<PackageDirectory*>(packageNode)) {
if (packageDirectory->FirstChild() != NULL) {
directory = dynamic_cast<Directory*>(node);
packageNode = packageDirectory->FirstChild();
directory->WriteLock();
continue;
}
}
}
// continue with the next available (ancestors's) sibling
do {
PackageDirectory* packageDirectory = packageNode->Parent();
PackageNode* sibling = packageDirectory != NULL
? packageDirectory->NextChild(packageNode) : NULL;
if (sibling != NULL) {
packageNode = sibling;
break;
}
// no more siblings -- go back up the tree
packageNode = packageDirectory;
directory->WriteUnlock();
directory = directory->Parent();
// the parent is still locked, so this is safe
} while (packageNode != NULL);
} while (packageNode != NULL);
return B_OK;
}
/*! Recursively iterates through the descendents of the given package root node
and removes all package nodes from the node tree in post-order, until
encountering \a endPackageNode (if non-null).
Due to limited kernel stack space we avoid deep recursive function calls
and rather use the package node stack implied by the tree.
*/
void
Volume::_RemovePackageContentRootNode(Package* package,
PackageNode* rootPackageNode, PackageNode* endPackageNode, bool notify)
{
PackageNode* packageNode = rootPackageNode;
Directory* directory = fRootDirectory;
directory->WriteLock();
do {
if (packageNode == endPackageNode)
break;
// recurse into directory
if (PackageDirectory* packageDirectory
= dynamic_cast<PackageDirectory*>(packageNode)) {
if (packageDirectory->FirstChild() != NULL) {
if (Directory* childDirectory = dynamic_cast<Directory*>(
directory->FindChild(packageNode->Name()))) {
directory = childDirectory;
packageNode = packageDirectory->FirstChild();
directory->WriteLock();
continue;
}
}
}
// continue with the next available (ancestors's) sibling
do {
PackageDirectory* packageDirectory = packageNode->Parent();
PackageNode* sibling = packageDirectory != NULL
? packageDirectory->NextChild(packageNode) : NULL;
// we're done with the node -- remove it
_RemovePackageNode(directory, packageNode,
directory->FindChild(packageNode->Name()), notify);
if (sibling != NULL) {
packageNode = sibling;
break;
}
// no more siblings -- go back up the tree
packageNode = packageDirectory;
directory->WriteUnlock();
directory = directory->Parent();
// the parent is still locked, so this is safe
} while (packageNode != NULL/* && packageNode != rootPackageNode*/);
} while (packageNode != NULL/* && packageNode != rootPackageNode*/);
}
status_t
Directory::AddPackageNode(PackageNode* packageNode)
{
if (!S_ISDIR(packageNode->Mode()))
return B_BAD_VALUE;
PackageDirectory* packageDirectory
= dynamic_cast<PackageDirectory*>(packageNode);
PackageDirectory* other = fPackageDirectories.Head();
bool isNewest = other == NULL
|| packageDirectory->ModifiedTime() > other->ModifiedTime();
if (isNewest)
fPackageDirectories.Insert(other, packageDirectory);
else
fPackageDirectories.Add(packageDirectory);
return B_OK;
}
void
Directory::RemovePackageNode(PackageNode* packageNode)
{
bool isNewest = packageNode == fPackageDirectories.Head();
fPackageDirectories.Remove(dynamic_cast<PackageDirectory*>(packageNode));
// when removing the newest node, we need to find the next node (the list
// is not sorted)
PackageDirectory* newestNode = fPackageDirectories.Head();
if (isNewest && newestNode != NULL) {
PackageDirectoryList::Iterator it = fPackageDirectories.GetIterator();
it.Next();
// skip the first one
while (PackageDirectory* otherNode = it.Next()) {
if (otherNode->ModifiedTime() > newestNode->ModifiedTime())
newestNode = otherNode;
}
fPackageDirectories.Remove(newestNode);
fPackageDirectories.Insert(fPackageDirectories.Head(), newestNode);
}
}
virtual status_t HandleEntry(BPackageEntry* 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);
}
status_t error;
// 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, entry->Data());
} else if (S_ISLNK(mode)) {
// symlink
PackageSymlink* symlink = new(std::nothrow) PackageSymlink(
fPackage, mode);
if (symlink == NULL)
RETURN_ERROR(B_NO_MEMORY);
error = symlink->SetSymlinkPath(entry->SymlinkPath());
if (error != B_OK) {
delete symlink;
return error;
}
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);
error = node->Init(parentDir, entry->Name());
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 HandleEntry(BPackageEntry* entry)
{
if (fErrorOccurred
|| (fLastSettingsEntry != NULL
&& fLastSettingsEntry->IsBlackListed())) {
return B_OK;
}
PackageDirectory* parentDir = NULL;
if (const BPackageEntry* parentEntry = entry->Parent()) {
if (!S_ISDIR(parentEntry->Mode()))
RETURN_ERROR(B_BAD_DATA);
parentDir = static_cast<PackageDirectory*>(
(PackageNode*)parentEntry->UserToken());
}
if (fSettingsItem != NULL
&& (parentDir == NULL
|| entry->Parent() == fLastSettingsEntryEntry)) {
PackageSettingsItem::Entry* settingsEntry
= fSettingsItem->FindEntry(fLastSettingsEntry, entry->Name());
if (settingsEntry != NULL) {
fLastSettingsEntry = settingsEntry;
fLastSettingsEntryEntry = entry;
if (fLastSettingsEntry->IsBlackListed())
return B_OK;
}
}
if (parentDir == NULL)
parentDir = fVolume->RootDirectory();
status_t error;
// 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(fVolume, mode, entry->Data());
} else if (S_ISLNK(mode)) {
// symlink
PackageSymlink* symlink = new(std::nothrow) PackageSymlink(
fVolume, mode);
if (symlink == NULL)
RETURN_ERROR(B_NO_MEMORY);
error = symlink->SetSymlinkPath(entry->SymlinkPath());
if (error != B_OK) {
delete symlink;
return error;
}
node = symlink;
} else if (S_ISDIR(mode)) {
// directory
node = new(std::nothrow) PackageDirectory(fVolume, mode);
} else
RETURN_ERROR(B_BAD_DATA);
if (node == NULL)
RETURN_ERROR(B_NO_MEMORY);
error = node->Init(parentDir, entry->Name(), fVolume->NextNodeID());
if (error != B_OK) {
delete node;
RETURN_ERROR(error);
}
node->SetModifiedTime(entry->ModifiedTime());
// add it to the parent directory
parentDir->AddChild(node);
entry->SetUserToken(node);
return B_OK;
}
