/*
 * Copyright 2011-2013, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Oliver Tappe <zooey@hirschkaefer.de>
 *              Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include <File.h>

#include <AutoDeleter.h>
#include <SHA256.h>

#include <package/ChecksumAccessors.h>


namespace BPackageKit {

namespace BPrivate {


#define NIBBLE_AS_HEX(nibble) \
        (nibble >= 10 ? 'a' + nibble - 10 : '0' + nibble)


// #pragma mark - ChecksumAccessor


ChecksumAccessor::~ChecksumAccessor()
{
}


// #pragma mark - ChecksumFileChecksumAccessor


ChecksumFileChecksumAccessor::ChecksumFileChecksumAccessor(
        const BEntry& checksumFileEntry)
        :
        fChecksumFileEntry(checksumFileEntry)
{
}


status_t
ChecksumFileChecksumAccessor::GetChecksum(BString& checksum) const
{
        BFile checksumFile(&fChecksumFileEntry, B_READ_ONLY);
        status_t result = checksumFile.InitCheck();
        if (result != B_OK)
                return result;

        const int kSHA256ChecksumHexDumpSize = 64;
        char* buffer = checksum.LockBuffer(kSHA256ChecksumHexDumpSize);
        if (buffer == NULL)
                return B_NO_MEMORY;

        ssize_t bytesRead = checksumFile.Read(buffer, kSHA256ChecksumHexDumpSize);
        buffer[kSHA256ChecksumHexDumpSize] = '\0';
        checksum.UnlockBuffer(kSHA256ChecksumHexDumpSize);
        if (bytesRead < 0)
                return bytesRead;
        if (bytesRead != kSHA256ChecksumHexDumpSize)
                return B_IO_ERROR;

        return B_OK;
}


// #pragma mark - GeneralFileChecksumAccessor


GeneralFileChecksumAccessor::GeneralFileChecksumAccessor(
        const BEntry& fileEntry, bool skipMissingFile)
        :
        fFileEntry(fileEntry),
        fSkipMissingFile(skipMissingFile)
{
}


status_t
GeneralFileChecksumAccessor::GetChecksum(BString& checksum) const
{
        SHA256 sha;

        checksum.Truncate(0);

        {
                BFile file(&fFileEntry, B_READ_ONLY);
                status_t result = file.InitCheck();
                if (result != B_OK) {
                        if (result == B_ENTRY_NOT_FOUND && fSkipMissingFile)
                                return B_OK;
                        return result;
                }

                off_t fileSize;
                if ((result = file.GetSize(&fileSize)) != B_OK)
                        return result;

                const int kBlockSize = 64 * 1024;
                void* buffer = malloc(kBlockSize);
                if (buffer == NULL)
                        return B_NO_MEMORY;
                MemoryDeleter memoryDeleter(buffer);

                off_t handledSize = 0;
                while (handledSize < fileSize) {
                        ssize_t bytesRead = file.Read(buffer, kBlockSize);
                        if (bytesRead < 0)
                                return bytesRead;

                        sha.Update(buffer, bytesRead);

                        handledSize += bytesRead;
                }
        }

        const int kSHA256ChecksumSize = sha.DigestLength();
        char* buffer = checksum.LockBuffer(2 * kSHA256ChecksumSize);
        if (buffer == NULL)
                return B_NO_MEMORY;
        const uint8* digest = sha.Digest();
        for (int i = 0; i < kSHA256ChecksumSize; ++i) {
                uint8 highNibble = (digest[i] & 0xF0) >> 4;
                buffer[i * 2] = NIBBLE_AS_HEX(highNibble);
                uint8 lowNibble = digest[i] & 0x0F;
                buffer[1 + i * 2] = NIBBLE_AS_HEX(lowNibble);
        }
        buffer[2 * kSHA256ChecksumSize] = '\0';
        checksum.UnlockBuffer(2 * kSHA256ChecksumSize);

        return B_OK;
}


// #pragma mark - StringChecksumAccessor


StringChecksumAccessor::StringChecksumAccessor(const BString& checksum)
        :
        fChecksum(checksum)
{
}


status_t
StringChecksumAccessor::GetChecksum(BString& _checksum) const
{
        _checksum = fChecksum;
        return B_OK;
}



}       // namespace BPrivate

}       // namespace BPackageKit