haiku.git

/*
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <RemoveEngine.h>

#include <errno.h>
#include <string.h>
#include <unistd.h>

#include <Directory.h>
#include <Entry.h>
#include <Path.h>


namespace BPrivate {


// #pragma mark - BRemoveEngine


BRemoveEngine::BRemoveEngine()
	:
	fController(NULL)
{
}


BRemoveEngine::~BRemoveEngine()
{
}


BRemoveEngine::BController*
BRemoveEngine::Controller() const
{
	return fController;
}


void
BRemoveEngine::SetController(BController* controller)
{
	fController = controller;
}


status_t
BRemoveEngine::RemoveEntry(const Entry& entry)
{
	BPath pathBuffer;
	const char* path;
	status_t error = entry.GetPath(pathBuffer, path);
	if (error != B_OK)
		return error;

	return _RemoveEntry(path);
}


status_t
BRemoveEngine::_RemoveEntry(const char* path)
{
	// apply entry filter
	if (fController != NULL && !fController->EntryStarted(path))
		return B_OK;

	// stat entry
	struct stat st;
	if (lstat(path, &st) < 0) {
		return _HandleEntryError(path, errno, "Couldn't access \"%s\": %s\n",
			path, strerror(errno));
	}

	// recurse, if entry is a directory
	if (S_ISDIR(st.st_mode)) {
		// open directory
		BDirectory directory;
		status_t error = directory.SetTo(path);
		if (error != B_OK) {
			return _HandleEntryError(path, error,
				"Failed to open directory \"%s\": %s\n", path, strerror(error));
		}

		char buffer[offsetof(struct dirent, d_name) + B_FILE_NAME_LENGTH];
		dirent *entry = (dirent*)buffer;
		while (directory.GetNextDirents(entry, sizeof(buffer), 1) == 1) {
			if (strcmp(entry->d_name, ".") == 0
				|| strcmp(entry->d_name, "..") == 0) {
				continue;
			}

			// construct child entry path
			BPath childPath;
			error = childPath.SetTo(path, entry->d_name);
			if (error != B_OK) {
				return _HandleEntryError(path, error,
					"Failed to construct entry path from dir \"%s\" and name "
					"\"%s\": %s\n", path, entry->d_name, strerror(error));
			}

			// remove the entry
			error = _RemoveEntry(childPath.Path());
			if (error != B_OK) {
				if (fController != NULL
					&& fController->EntryFinished(path, error)) {
					return B_OK;
				}
				return error;
			}
		}
	}

	// remove entry
	if (S_ISDIR(st.st_mode)) {
		if (rmdir(path) < 0) {
			return _HandleEntryError(path, errno,
				"Failed to remove \"%s\": %s\n", path, strerror(errno));
		}
	} else {
		if (unlink(path) < 0) {
			return _HandleEntryError(path, errno,
				"Failed to unlink \"%s\": %s\n", path, strerror(errno));
		}
	}

	if (fController != NULL)
		fController->EntryFinished(path, B_OK);

	return B_OK;
}


void
BRemoveEngine::_NotifyErrorVarArgs(status_t error, const char* format,
	va_list args)
{
	if (fController != NULL) {
		BString message;
		message.SetToFormatVarArgs(format, args);
		fController->ErrorOccurred(message, error);
	}
}


status_t
BRemoveEngine::_HandleEntryError(const char* path, status_t error,
	const char* format, ...)
{
	if (fController == NULL)
		return error;

	va_list args;
	va_start(args, format);
	_NotifyErrorVarArgs(error, format, args);
	va_end(args);

	if (fController->EntryFinished(path, error))
		return B_OK;
	return error;
}


// #pragma mark - BController


BRemoveEngine::BController::BController()
{
}


BRemoveEngine::BController::~BController()
{
}


bool
BRemoveEngine::BController::EntryStarted(const char* path)
{
	return true;
}


bool
BRemoveEngine::BController::EntryFinished(const char* path, status_t error)
{
	return error == B_OK;
}


void
BRemoveEngine::BController::ErrorOccurred(const char* message, status_t error)
{
}


} // namespace BPrivate