haiku.git

/*
 * Copyright 2018-2023, Andrew Lindesay <apl@lindesay.co.nz>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */
#include "DataIOUtils.h"


#define BUFFER_SIZE 1024


/*static*/ status_t
DataIOUtils::CopyAll(BDataIO* target, BDataIO* source)
{
	status_t result = B_OK;
	uint8 buffer[BUFFER_SIZE];
	size_t sizeRead = 0;

	do {
		result = source->ReadExactly(buffer, BUFFER_SIZE, &sizeRead);

		switch (result)
		{
			case B_OK:
			case B_PARTIAL_READ:
				result = target->WriteExactly(buffer, sizeRead);
				break;
		}
	} while(result == B_OK && sizeRead > 0);

	return result;
}


// #pragma mark - ConstraintedDataIO

ConstraintedDataIO::ConstraintedDataIO(BDataIO* delegate, size_t limit)
	:
	fDelegate(delegate),
	fLimit(limit)
{
}


ConstraintedDataIO::~ConstraintedDataIO()
{
}


ssize_t
ConstraintedDataIO::Read(void* buffer, size_t size)
{
	if (size > fLimit)
		size = fLimit;

	ssize_t actualRead = fDelegate->Read(buffer, size);

	if (actualRead > 0)
		fLimit -= actualRead;

	return actualRead;
}


ssize_t
ConstraintedDataIO::Write(const void* buffer, size_t size)
{
	return B_NOT_SUPPORTED;
}


status_t
ConstraintedDataIO::Flush()
{
	return B_OK;
}


// #pragma mark - Base64DecodingDataIO

Base64DecodingDataIO::Base64DecodingDataIO(BDataIO* delegate, char char62, char char63)
	:
	fDelegate(delegate),
	fChar62(char62),
	fChar63(char63),
	fNextByteAssembly(0),
    fNextByteAssemblyBits(0)
{
}


Base64DecodingDataIO::~Base64DecodingDataIO()
{
}


status_t
Base64DecodingDataIO::_CharToInt(uint8 ch, uint8* value)
{
	if (ch >= 0x41 && ch <= 0x5A) {
		*value = (ch - 0x41);
		return B_OK;
	}

	if (ch >= 0x61 && ch <= 0x7a) {
		*value = (ch - 0x61) + 26;
		return B_OK;
	}

	if (ch >= 0x30 && ch <= 0x39) {
		*value = (ch - 0x30) + 52;
		return B_OK;
	}

	if (ch == fChar62) {
		*value = 62;
		return B_OK;
	}

	if (ch == fChar63) {
		*value = 63;
		return B_OK;
	}

	if (ch == '=') {
		*value = 0;
		return B_OK;
	}

	return B_BAD_DATA;
}


status_t
Base64DecodingDataIO::_ReadSingleByte(void* buffer)
{
	uint8 delegateRead;
	uint8 delegateReadInt;
	status_t result = B_OK;

	if (result == B_OK)
		result = fDelegate->ReadExactly(&delegateRead, 1);

	if (result == B_OK)
		result = _CharToInt(delegateRead, &delegateReadInt);

	if (result == B_OK && 0 == fNextByteAssemblyBits) {
		fNextByteAssembly = delegateReadInt;
		fNextByteAssemblyBits = 6;
		return _ReadSingleByte(buffer);
	}

	if (result == B_OK) {
		uint8 followingNextByteAssemblyBits = (6 - (8 - fNextByteAssemblyBits));
		*((uint8 *) buffer) = fNextByteAssembly << (8 - fNextByteAssemblyBits)
			| (delegateReadInt >> followingNextByteAssemblyBits);
		fNextByteAssembly = delegateReadInt & (0x3f >> (6 - followingNextByteAssemblyBits));
		fNextByteAssemblyBits = followingNextByteAssemblyBits;
	}

	return result;
}


ssize_t
Base64DecodingDataIO::Read(void* buffer, size_t size)
{
	size_t readSize = 0;
	status_t result = B_OK;

	while (result == B_OK && readSize < size) {
		result = _ReadSingleByte(&((uint8_t*) buffer)[readSize]);

		if (result == B_OK)
			readSize++;
	}

	return readSize++;
}


ssize_t
Base64DecodingDataIO::Write(const void* buffer, size_t size)
{
	return B_NOT_SUPPORTED;
}


status_t
Base64DecodingDataIO::Flush()
{
	return B_OK;
}