haiku.git

/*
 * Copyright 2011-2021, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler <axeld@pinc-software.de>
 *		Rene Gollent <rene@gollent.com>
 *		Oliver Tappe <zooey@hirschkaefer.de>
 *		Stephan Aßmus <superstippi@gmx.de>
 */


#include "FetchFileJob.h"

#include <stdio.h>
#include <sys/wait.h>

#include <Path.h>

#ifdef HAIKU_TARGET_PLATFORM_HAIKU
#	include <HttpRequest.h>
#	include <UrlRequest.h>
#	include <UrlProtocolRoster.h>
using namespace BPrivate::Network;
#endif

#include "FetchUtils.h"


namespace BPackageKit {

namespace BPrivate {


#ifdef HAIKU_TARGET_PLATFORM_HAIKU

FetchFileJob::FetchFileJob(const BContext& context, const BString& title,
	const BString& fileURL, const BEntry& targetEntry)
	:
	inherited(context, title),
	fFileURL(fileURL),
	fTargetEntry(targetEntry),
	fTargetFile(&targetEntry, B_CREATE_FILE | B_WRITE_ONLY),
	fError(B_ERROR),
	fDownloadProgress(0.0)
{
}


FetchFileJob::~FetchFileJob()
{
}


float
FetchFileJob::DownloadProgress() const
{
	return fDownloadProgress;
}


const char*
FetchFileJob::DownloadURL() const
{
	return fFileURL.String();
}


const char*
FetchFileJob::DownloadFileName() const
{
	return fTargetEntry.Name();
}


off_t
FetchFileJob::DownloadBytes() const
{
	return fBytes;
}


off_t
FetchFileJob::DownloadTotalBytes() const
{
	return fTotalBytes;
}


status_t
FetchFileJob::Execute()
{
	status_t result = fTargetFile.InitCheck();
	if (result != B_OK)
		return result;

	result = FetchUtils::SetFileType(fTargetFile,
		"application/x-vnd.haiku-package");
	if (result != B_OK) {
		fprintf(stderr, "failed to set file type for '%s': %s\n",
			DownloadFileName(), strerror(result));
	}

	do {
		BUrlRequest* request = BUrlProtocolRoster::MakeRequest(fFileURL.String(),
			&fTargetFile, this);
		if (request == NULL)
			return B_BAD_VALUE;

		// Try to resume the download where we left off
		off_t currentPosition;
		BHttpRequest* http = dynamic_cast<BHttpRequest*>(request);
		if (http != NULL && fTargetFile.GetSize(&currentPosition) == B_OK
			&& currentPosition > 0) {
			http->SetRangeStart(currentPosition);
			fTargetFile.Seek(0, SEEK_END);
		}

		thread_id thread = request->Run();
		wait_for_thread(thread, NULL);

		if (fError != B_IO_ERROR && fError != B_DEV_TIMEOUT && fError != B_OK) {
			// Something went wrong with the download and it's not just a
			// timeout. Remove whatever we wrote to the file, since the content
			// returned by the server was probably not part of the file.
			fTargetFile.SetSize(currentPosition);
		}
	} while (fError == B_IO_ERROR || fError == B_DEV_TIMEOUT);

	if (fError == B_OK) {
		result = FetchUtils::MarkDownloadComplete(fTargetFile);
		if (result != B_OK) {
			fprintf(stderr, "failed to mark download '%s' as complete: %s\n",
				DownloadFileName(), strerror(result));
		}
	}

	return fError;
}


void
FetchFileJob::DownloadProgress(BUrlRequest*, off_t bytesReceived,
	off_t bytesTotal)
{
	if (bytesTotal != 0) {
		fBytes = bytesReceived;
		fTotalBytes = bytesTotal;
		fDownloadProgress = (float)bytesReceived/bytesTotal;
		NotifyStateListeners();
	}
}


void
FetchFileJob::RequestCompleted(BUrlRequest* request, bool success)
{
	fError = request->Status();

	if (success) {
		const BHttpResult* httpResult = dynamic_cast<const BHttpResult*>
			(&request->Result());
		if (httpResult != NULL) {
			uint16 code = httpResult->StatusCode();
			uint16 codeClass = BHttpRequest::StatusCodeClass(code);

			switch (codeClass) {
				case B_HTTP_STATUS_CLASS_CLIENT_ERROR:
				case B_HTTP_STATUS_CLASS_SERVER_ERROR:
					fError = B_IO_ERROR;
					break;
				default:
					fError = B_OK;
					break;
			}
			switch (code) {
				case B_HTTP_STATUS_OK:
				case B_HTTP_STATUS_PARTIAL_CONTENT:
					fError = B_OK;
					break;
				case B_HTTP_STATUS_REQUEST_TIMEOUT:
				case B_HTTP_STATUS_GATEWAY_TIMEOUT:
					fError = B_DEV_TIMEOUT;
					break;
				case B_HTTP_STATUS_NOT_IMPLEMENTED:
					fError = B_NOT_SUPPORTED;
					break;
				case B_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE:
					fError = B_UNKNOWN_MIME_TYPE;
					break;
				case B_HTTP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE:
					fError = B_RESULT_NOT_REPRESENTABLE; // alias for ERANGE
					break;
				case B_HTTP_STATUS_UNAUTHORIZED:
					fError = B_PERMISSION_DENIED;
					break;
				case B_HTTP_STATUS_FORBIDDEN:
				case B_HTTP_STATUS_METHOD_NOT_ALLOWED:
				case B_HTTP_STATUS_NOT_ACCEPTABLE:
					fError = B_NOT_ALLOWED;
					break;
				case B_HTTP_STATUS_NOT_FOUND:
					fError = B_NAME_NOT_FOUND;
					break;
				case B_HTTP_STATUS_BAD_GATEWAY:
					fError = B_BAD_DATA;
					break;
				default:
					break;
			}
		}
	}
}


void
FetchFileJob::Cleanup(status_t jobResult)
{
	if (jobResult != B_OK)
		fTargetEntry.Remove();
}


#else // HAIKU_TARGET_PLATFORM_HAIKU


FetchFileJob::FetchFileJob(const BContext& context, const BString& title,
	const BString& fileURL, const BEntry& targetEntry)
	:
	inherited(context, title),
	fFileURL(fileURL),
	fTargetEntry(targetEntry),
	fTargetFile(&targetEntry, B_CREATE_FILE | B_WRITE_ONLY),
	fDownloadProgress(0.0)
{
}


FetchFileJob::~FetchFileJob()
{
}


float
FetchFileJob::DownloadProgress() const
{
	return fDownloadProgress;
}


const char*
FetchFileJob::DownloadURL() const
{
	return fFileURL.String();
}


const char*
FetchFileJob::DownloadFileName() const
{
	return fTargetEntry.Name();
}


off_t
FetchFileJob::DownloadBytes() const
{
	return fBytes;
}


off_t
FetchFileJob::DownloadTotalBytes() const
{
	return fTotalBytes;
}


status_t
FetchFileJob::Execute()
{
	return B_UNSUPPORTED;
}


void
FetchFileJob::Cleanup(status_t jobResult)
{
	if (jobResult != B_OK)
		fTargetEntry.Remove();
}


#endif // HAIKU_TARGET_PLATFORM_HAIKU

}	// namespace BPrivate

}	// namespace BPackageKit