checksum::md5sum Class Reference

class to calculate md5sums. More...

#include <md5sum.h>

Inheritance diagram for checksum::md5sum:

Collaboration diagram for checksum::md5sum:

Public Member Functions
	md5sum (const std::string &name)
void	update (void *data, size_t size) override
	proces size bytes in the block at data More...
void	update (size_t size) override
	proces size many zero bytes More...
void	finish () override
	finish calculation ad write to result More...
Public Member Functions inherited from checksum::base
virtual	~base ()=default
virtual bool	parallelizable () const
const std::string &	getName () const
const std::string &	getResult () const
void	setExpectedResult (const std::string &expectedResult)
const std::string &	getExpectedResult () const
bool	checkExpectation () const

Private Attributes
struct md5_ctx	ctx

Static Private Attributes
static factoryTemplate< md5sum >	factory

Additional Inherited Members
Static Public Member Functions inherited from checksum::base
static factoryClass *	newFactory (const std::string &aName)
template<class T >
static void	addAllowedNamesToOption (T &option)
Protected Member Functions inherited from checksum::base
	base (const std::string &aName)
Static Protected Member Functions inherited from checksum::base
static std::map< std::string, factoryClass * > &	getFactoryMap ()
Protected Attributes inherited from checksum::base
const std::string &	name
std::string	result
std::string	expected

Detailed Description

class to calculate md5sums.

Wrappers either the openssl implementation or a copy of the md5 implementation from the gnulib as it is used in the md5sum command.

Definition at line 18 of file md5sum.h.

Constructor & Destructor Documentation

md5sum()

checksum::md5sum::md5sum

(

const std::string &

name

)

Definition at line 10 of file md5sum.cpp.

                                         : base(aName) {
        #ifdef USE_OPENSSL
        ctx = EVP_MD_CTX_create();
        mdType = EVP_md5();
        EVP_MD_CTX_init(ctx);
        EVP_DigestInit_ex(ctx, mdType, nullptr);
        #else
        __md5_init_ctx(&ctx);
        #endif
    }

References __md5_init_ctx, and ctx.

Member Function Documentation

finish()

void checksum::md5sum::finish ( )

overridevirtual

finish calculation ad write to result

Implements checksum::base.

Definition at line 70 of file md5sum.cpp.

                        {
        #ifdef USE_OPENSSL
        std::vector<unsigned char> md(EVP_MD_size(mdType));
        EVP_DigestFinal_ex(ctx, md.data(), nullptr);
        EVP_MD_CTX_cleanup(ctx);
        EVP_MD_CTX_destroy(ctx);
        #else
        unsigned char md[16];
        __md5_finish_ctx(&ctx, md);
        #endif
        std::ostringstream hashBuffer;
 
        for (auto c : md) {
            hashBuffer << std::hex << std::setw(2) << std::setfill('0') << static_cast<unsigned int>(c);
        }
 
        result = hashBuffer.str();
    }

References __md5_finish_ctx, ctx, and checksum::base::result.

update() [1/2]

void checksum::md5sum::update ( size_t  size )

overridevirtual

proces size many zero bytes

Implements checksum::base.

Definition at line 44 of file md5sum.cpp.

                                    { // case for block of zeroes
        #ifndef USE_OPENSSL
        if ((size & (64 - 1)) == 0) {
            __md5_process_zero(size, &ctx);
        } else
        #endif
        {
            for (size_t bytes_done = 0; bytes_done < size;) {
                auto missing = size - bytes_done;
                auto bytes = std::min(missing, block::nullBufferSize());
                #ifdef USE_OPENSSL
                EVP_DigestUpdate(ctx, block::nullBuffer(), bytes);
                #else
 
                if (size & (64 - 1)) { // use processor that needs no 64Byte size
                    __md5_process_bytes(block::nullBuffer(), bytes, &ctx);
                } else {
                    __md5_process_zero(bytes, &ctx);
                }
 
                #endif
                bytes_done += bytes;
            }
        }
    }

References __md5_process_bytes, __md5_process_zero, ctx, block::nullBuffer(), and block::nullBufferSize().

Here is the call graph for this function:

update() [2/2]

void checksum::md5sum::update ( void *  data, size_t  size  )

overridevirtual

proces size bytes in the block at data

Implements checksum::base.

Definition at line 20 of file md5sum.cpp.

                                                {
        for (size_t bytes_done = 0; bytes_done < size;) {
            size_t bytes = 4096;
            auto missing = size - bytes_done;
 
            if (missing < bytes) {
                bytes = missing;
            }
 
            auto dataStart = static_cast<void*>(static_cast<char*>(data) + bytes_done);
            #ifdef USE_OPENSSL
            EVP_DigestUpdate(ctx, dataStart, bytes);
            #else
 
            if (size & (64 - 1)) { // use processor that needs no 64Byte size
                __md5_process_bytes(dataStart, bytes, &ctx);
            } else {
                __md5_process_block(dataStart, bytes, &ctx);
            }
 
            #endif
            bytes_done += bytes;
        }
    }

References __md5_process_block, __md5_process_bytes, and ctx.

Member Data Documentation

ctx

struct md5_ctx checksum::md5sum::ctx

private

Definition at line 25 of file md5sum.h.

Referenced by finish(), md5sum(), and update().

factory

factoryTemplate<md5sum> checksum::md5sum::factory

staticprivate

Definition at line 20 of file md5sum.h.

---

The documentation for this class was generated from the following files:

• src/md5sum.h (v0.19-24-g0617ca1 with changes)
• src/md5sum.cpp (v0.19-24-g0617ca1 with changes)