Subversion Repositories tpanel

/*
 * Copyright (C) 2022 by Andreas Theofilu <andreas@theosys.at>
 *
 * 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 3 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 */

#include "tcrc32.h"
#include "tresources.h"
#include "terror.h"

using std::vector;

TCrc32::TCrc32(const vector<uint8_t>& bytes)
{
    DECL_TRACER("TCrc32::TCrc32(const vector<uint8_t>& bytes)");

    uint32_t salt = 0;
    size_t pos = 0;

    for (size_t i = 0; i < bytes.size(); ++i)
    {
        uint32_t b = static_cast<uint32_t>(bytes[i]);

        if (b == 0 && bytes.size() > 4)
            continue;

        salt |= (b << (pos * 8));

        if (pos >= 4)
            break;

        pos++;
    }

    mCrc32 = calculate_crc32c(salt, bytes.data(), bytes.size());
}

uint32_t TCrc32::crc32c_sb8_64_bit(uint32_t crc, const unsigned char *p_buf, uint32_t length, uint32_t init_bytes)
{
    DECL_TRACER("TCrc32::crc32c_sb8_64_bit(uint32_t crc, const unsigned char *p_buf, uint32_t length, uint32_t init_bytes)");

    uint32_t li;
    uint32_t term1, term2;
    uint32_t running_length;
    uint32_t end_bytes;

    running_length = ((length - init_bytes) / 8) * 8;
    end_bytes = length - init_bytes - running_length;

    for (li = 0; li < init_bytes; li++)
        crc = sctp_crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8);

    for (li = 0; li < running_length / 8; li++)
    {
        if (isBigEndian())
        {
            crc ^= *p_buf++;
            crc ^= (*p_buf++) << 8;
            crc ^= (*p_buf++) << 16;
            crc ^= (*p_buf++) << 24;
        }
        else
        {
            crc ^= *(const uint32_t *) p_buf;
            p_buf += 4;
        }

        term1 = sctp_crc_tableil8_o88[crc & 0x000000FF] ^ sctp_crc_tableil8_o80[(crc >> 8) & 0x000000FF];
        term2 = crc >> 16;
        crc = term1 ^ sctp_crc_tableil8_o72[term2 & 0x000000FF] ^ sctp_crc_tableil8_o64[(term2 >> 8) & 0x000000FF];

        if (isBigEndian())
        {
            crc ^= sctp_crc_tableil8_o56[*p_buf++];
            crc ^= sctp_crc_tableil8_o48[*p_buf++];
            crc ^= sctp_crc_tableil8_o40[*p_buf++];
            crc ^= sctp_crc_tableil8_o32[*p_buf++];
        }
        else
        {
            term1 = sctp_crc_tableil8_o56[(*(const uint32_t *) p_buf) & 0x000000FF] ^ sctp_crc_tableil8_o48[((*(const uint32_t *) p_buf) >> 8) & 0x000000FF];

            term2 = (*(const uint32_t *) p_buf) >> 16;
            crc = crc ^ term1 ^ sctp_crc_tableil8_o40[term2 & 0x000000FF] ^ sctp_crc_tableil8_o32[(term2 >> 8) & 0x000000FF];
            p_buf += 4;
        }
    }

    for (li = 0; li < end_bytes; li++)
        crc = sctp_crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8);

    return crc;
}

uint32_t TCrc32::multitable_crc32c(uint32_t crc32c, const unsigned char *buffer, unsigned int length)
{
    DECL_TRACER("TCrc32::multitable_crc32c(uint32_t crc32c, const unsigned char *buffer, unsigned int length)");

    uint32_t to_even_word;

    if (length == 0)
        return (crc32c);

    to_even_word = (4 - (((uintptr_t) buffer) & 0x3));
    return (crc32c_sb8_64_bit(crc32c, buffer, length, to_even_word));
}

uint32_t TCrc32::singletable_crc32c(uint32_t crc, const void *buf, size_t size)
{
    DECL_TRACER("TCrc32::singletable_crc32c(uint32_t crc, const void *buf, size_t size)");

    const uint8_t *p = (uint8_t *)buf;

    while (size--)
        crc = crc32Table[(crc ^ *p++) & 0xff] ^ (crc >> 8);

    return crc;
}

uint32_t TCrc32::calculate_crc32c(uint32_t crc32c, const unsigned char *buffer, unsigned int length)
{
    DECL_TRACER("TCrc32::calculate_crc32c(uint32_t crc32c, const unsigned char *buffer, unsigned int length)");

    if (!buffer || !length)
        return 0;

    std::stringstream s;
    s << std::setw(8) << std::setfill('0') << std::hex << crc32c;
    MSG_DEBUG("Calculating CRC32 with the salt " << s.str() << " and a length of " << length << " bytes.");

    if (length < 4)
        return (singletable_crc32c(crc32c, buffer, length));
    else
        return (multitable_crc32c(crc32c, buffer, length));
}