haiku.git

/*
 * Copyright 2002-2009 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Tyler Dauwalder
 *		Ingo Weinhold, ingo_weinhold@gmx.de
 */


#include <new>
#include <string.h>

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

#include <syscalls.h>

#include "storage_support.h"


using namespace std;


// Creates an uninitialized BSymLink object.
BSymLink::BSymLink()
{
}


// Creates a copy of the supplied BSymLink object.
BSymLink::BSymLink(const BSymLink& other)
	:
	BNode(other)
{
}


// Creates a BSymLink object and initializes it to the symbolic link referred
// to by the supplied entry_ref.
BSymLink::BSymLink(const entry_ref* ref)
	:
	BNode(ref)
{
}


// Creates a BSymLink object and initializes it to the symbolic link referred
// to by the supplied BEntry.
BSymLink::BSymLink(const BEntry* entry)
		: BNode(entry)
{
}


// Creates a BSymLink object and initializes it to the symbolic link referred
// to by the supplied path name.
BSymLink::BSymLink(const char* path)
	:
	BNode(path)
{
}


// Creates a BSymLink object and initializes it to the symbolic link referred
// to by the supplied path name relative to the specified BDirectory.
BSymLink::BSymLink(const BDirectory* dir, const char* path)
	:
	BNode(dir, path)
{
}


// Destroys the object and frees all allocated resources.
BSymLink::~BSymLink()
{
}


// Reads the contents of the symbolic link into a buffer.
ssize_t
BSymLink::ReadLink(char* buffer, size_t size)
{
	if (buffer == NULL)
		return B_BAD_VALUE;

	if (InitCheck() != B_OK)
		return B_FILE_ERROR;

	size_t linkLen = size;
	status_t result = _kern_read_link(get_fd(), NULL, buffer, &linkLen);
	if (result < B_OK)
		return result;

	if (linkLen < size)
		buffer[linkLen] = '\0';
	else if (size > 0)
		buffer[size - 1] = '\0';

	return linkLen;
}


// Combines a directory path and the contents of this symbolic link to form an
// absolute path.
ssize_t
BSymLink::MakeLinkedPath(const char* dirPath, BPath* path)
{
	// BeOS seems to convert the dirPath to a BDirectory, which causes links
	// to be resolved. This means that the dirPath must exist!
	if (dirPath == NULL || path == NULL)
		return B_BAD_VALUE;

	BDirectory dir(dirPath);
	ssize_t result = dir.InitCheck();
	if (result == B_OK)
		result = MakeLinkedPath(&dir, path);

	return result;
}


// Combines a directory path and the contents of this symbolic link to form an
// absolute path.
ssize_t
BSymLink::MakeLinkedPath(const BDirectory* dir, BPath* path)
{
	if (dir == NULL || path == NULL)
		return B_BAD_VALUE;

	char contents[B_PATH_NAME_LENGTH];
	ssize_t result = ReadLink(contents, sizeof(contents));
	if (result >= 0) {
		if (BPrivate::Storage::is_absolute_path(contents))
			result = path->SetTo(contents);
		else
			result = path->SetTo(dir, contents);

		if (result == B_OK)
			result = strlen(path->Path());
	}

	return result;
}


// Returns whether or not the object refers to an absolute path.
bool
BSymLink::IsAbsolute()
{
	char contents[B_PATH_NAME_LENGTH];
	bool result = (ReadLink(contents, sizeof(contents)) >= 0);
	if (result)
		result = BPrivate::Storage::is_absolute_path(contents);

	return result;
}


void BSymLink::_MissingSymLink1() {}
void BSymLink::_MissingSymLink2() {}
void BSymLink::_MissingSymLink3() {}
void BSymLink::_MissingSymLink4() {}
void BSymLink::_MissingSymLink5() {}
void BSymLink::_MissingSymLink6() {}


/*!	Returns the file descriptor of the BSymLink.

	This method should be used instead of accessing the private \c fFd member
	of the BNode directly.

	\return The object's file descriptor, or -1 if not properly initialized.
*/
int
BSymLink::get_fd() const
{
	return fFd;
}