haiku.git

/*
 * Copyright 2013-2014 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 * 		Adrien Destugues, pulkomandy@pulkomandy.tk
 */


#include <assert.h>
#include <stdlib.h>

#include <Directory.h>
#include <File.h>
#include <FileRequest.h>
#include <NodeInfo.h>
#include <Path.h>

using namespace BPrivate::Network;


BFileRequest::BFileRequest(const BUrl& url, BDataIO* output,
	BUrlProtocolListener* listener, BUrlContext* context)
	:
	BUrlRequest(url, output, listener, context, "BUrlProtocol.File", "file"),
	fResult()
{
}


BFileRequest::~BFileRequest()
{
	status_t status = Stop();
	if (status == B_OK)
		wait_for_thread(fThreadId, &status);
}


const BUrlResult&
BFileRequest::Result() const
{
	return fResult;
}


status_t
BFileRequest::_ProtocolLoop()
{
	BNode node(fUrl.Path().String());

	if (node.IsSymLink()) {
		// Traverse the symlink and start over
		BEntry entry(fUrl.Path().String(), true);
		node = BNode(&entry);
	}

	ssize_t transferredSize = 0;
	if (node.IsFile()) {
		BFile file(fUrl.Path().String(), B_READ_ONLY);
		status_t error = file.InitCheck();
		if (error != B_OK)
			return error;

		BNodeInfo info(&file);
		char mimeType[B_MIME_TYPE_LENGTH + 1];
		if (info.GetType(mimeType) != B_OK)
			update_mime_info(fUrl.Path().String(), false, true, false);
		if (info.GetType(mimeType) == B_OK)
			fResult.SetContentType(mimeType);

		// Send all notifications to listener, if any
		if (fListener != NULL)
			fListener->ConnectionOpened(this);

		off_t size = 0;
		error = file.GetSize(&size);
		if (error != B_OK)
			return error;
		fResult.SetLength(size);

		if (fListener != NULL)
			fListener->HeadersReceived(this);

		if (fOutput != NULL) {
			ssize_t chunkSize = 0;
			char chunk[4096];
			while (!fQuit) {
				chunkSize = file.Read(chunk, sizeof(chunk));
				if (chunkSize > 0) {
					size_t written = 0;
					error = fOutput->WriteExactly(chunk, chunkSize, &written);
					if (fListener != NULL && written > 0)
						fListener->BytesWritten(this, written);
					if (error != B_OK)
						return error;
					transferredSize += chunkSize;
					if (fListener != NULL)
						fListener->DownloadProgress(this, transferredSize,
							size);
				} else
					break;
			}
			if (fQuit)
				return B_INTERRUPTED;
			// Return error if we didn't transfer everything
			if (transferredSize != size) {
				if (chunkSize < 0)
					return (status_t)chunkSize;
				else
					return B_IO_ERROR;
			}
		}

		return B_OK;
	}

	node_ref ref;
	status_t error = node.GetNodeRef(&ref);

	// Stop here, and don't hit the assert below, if the file doesn't exist.
	if (error != B_OK)
		return error;

	assert(node.IsDirectory());
	BDirectory directory(&ref);

	fResult.SetContentType("application/x-ftp-directory; charset=utf-8");
		// This tells WebKit to use its FTP directory rendering code.

	if (fListener != NULL) {
		fListener->ConnectionOpened(this);
		fListener->HeadersReceived(this);
	}

	if (fOutput != NULL) {
		// Add a parent directory entry.
		size_t written = 0;
		error = fOutput->WriteExactly("+/,\t..\r\n", 8, &written);
		if (fListener != NULL && written > 0)
			fListener->BytesWritten(this, written);
		if (error != B_OK)
			return error;
		transferredSize += written;
		if (fListener != NULL)
			fListener->DownloadProgress(this, transferredSize, 0);

		char name[B_FILE_NAME_LENGTH];
		BEntry entry;
		while (!fQuit && directory.GetNextEntry(&entry) != B_ENTRY_NOT_FOUND) {
			// We read directories using the EPLF (Easily Parsed List Format)
			// This happens to be one of the formats that WebKit can understand,
			// and it is not too hard to parse or generate.
			// http://tools.ietf.org/html/draft-bernstein-eplf-02
			BString eplf("+");
			if (entry.IsFile() || entry.IsSymLink()) {
				eplf += "r,";
				off_t fileSize;
				if (entry.GetSize(&fileSize) == B_OK)
					eplf << "s" << fileSize << ",";
			} else if (entry.IsDirectory())
				eplf += "/,";

			time_t modification;
			if (entry.GetModificationTime(&modification) == B_OK)
				eplf << "m" << modification << ",";

			mode_t permissions;
			if (entry.GetPermissions(&permissions) == B_OK)
				eplf << "up" << BString().SetToFormat("%03o", permissions) << ",";

			node_ref ref;
			if (entry.GetNodeRef(&ref) == B_OK)
				eplf << "i" << ref.device << "." << ref.node << ",";

			entry.GetName(name);
			eplf << "\t" << name << "\r\n";
			size_t written = 0;
			error = fOutput->WriteExactly(eplf.String(), eplf.Length(),
				&written);
			if (fListener != NULL && written > 0)
				fListener->BytesWritten(this, written);
			if (error != B_OK)
				return error;
			transferredSize += written;
			if (fListener != NULL)
				fListener->DownloadProgress(this, transferredSize, 0);
		}

		if (!fQuit)
			fResult.SetLength(transferredSize);
	}

	return fQuit ? B_INTERRUPTED : B_OK;
}