/*
 *  Baltisot
 *  Copyright (C) 1999-2007 Nicolas "Pixel" Noble
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <sha1.h>
#include <sha256.h>
#include <md5.h>

#include <HashFunction.h>

static const char hconv[] = "0123456789ABCDEF";

HashFunction::HashFunction() {
    finished = false;
    l = 0;
}

void HashFunction::Update(const String & str) {
    update((unsigned char *) str.to_charp(), str.strlen());
}

void HashFunction::Update(const unsigned char * data, size_t len) {
    update(data, len);
}

#define BLKSIZE 16384
void HashFunction::Update(Handle * h, ssize_t size) {
    Uint8 blk[BLKSIZE];
    long r;
    
    if (size < 0)
        size = h->GetSize();
    
    while (size) {
        if ((size > BLKSIZE) || (size < 0)) {
            r = h->read(blk, BLKSIZE);
            if (r)
                Update(blk, r);
        } else {
            r = h->read(blk, size);
            if (r)
                Update(blk, r);
        }
        if (!r)
            break;
        if (size > 0)
            size -= r;
    }
}

String HashFunction::Finish() {
    char digest_r[513];
    int i;

    if (!finished)    
        l = finish(digest);
    finished = true;
    
    for (i = 0; i < l; i++) {
        digest_r[i * 2 + 0] = hconv[digest[i] >> 4];
        digest_r[i * 2 + 1] = hconv[digest[i] % 16];
    }
    digest_r[l * 2] = 0;
    
    return digest_r;
}

size_t HashFunction::RFinish(Uint8 * _digest) {
    if (!finished)
        l = finish(digest);
    finished = true;
    
    memcpy(_digest, digest, l);

    return l;
}

size_t HashFunction::finish() {
    if (!finished)
        l = finish(digest);
    finished = true;
    
    return l;    
}

SHA1::SHA1() {
    opaque = (sha1_context *) malloc(sizeof(sha1_context));
    sha1_starts((sha1_context *) opaque);
}

SHA1::~SHA1() {
    free(opaque);
}

void SHA1::update(const unsigned char * data, size_t len) {
    sha1_update((sha1_context *) opaque, data, len);
}

size_t SHA1::finish(Uint8 * digest) {
    sha1_finish((sha1_context *) opaque, digest);
    
    return size();
}

size_t SHA1::size() {
    return 20;
}

SHA256::SHA256() {
    opaque = (sha256_context *) malloc(sizeof(sha256_context));
    sha256_starts((sha256_context *) opaque);
}

SHA256::~SHA256() {
    free(opaque);
}

void SHA256::update(const unsigned char * data, size_t len) {
    sha256_update((sha256_context *) opaque, data, len);
}

size_t SHA256::finish(Uint8 * digest) {
    sha256_finish((sha256_context *) opaque, digest);
    
    return size();
}

size_t SHA256::size() {
    return 32;
}

MD5::MD5() {
    opaque = (md5_context *) malloc(sizeof(md5_context));
    md5_starts((md5_context *) opaque);
}

MD5::~MD5() {
    free(opaque);
}

void MD5::update(const unsigned char * data, size_t len) {
    md5_update((md5_context *) opaque, data, len);
}

size_t MD5::finish(Uint8 * digest) {
    md5_finish((md5_context *) opaque, digest);
    
    return size();
}

size_t MD5::size() {
    return 16;
}