Cppcheck - HTML report - GATE C/C++ Framework

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/randomgen.h"
#include "gate/results.h"

#if defined(GATE_SYS_WIN16)
#	define GATE_CORE_RANDOM_GATE_IMPL 1
#elif defined(GATE_SYS_WIN)
#	define GATE_CORE_RANDOM_WINAPI_IMPL 1
#elif defined(GATE_SYS_POSIX)
#	define GATE_CORE_RANDOM_POSIX_IMPL 1
#else
#	define GATE_CORE_RANDOM_GATE_IMPL 1
#endif



#if defined(GATE_CORE_RANDOM_WINAPI_IMPL)

#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0400
#endif

#include "gate/platforms.h"
#include "gate/debugging.h"

#include <wincrypt.h>
#if defined(GATE_SYS_WINSTORE)
#	include <bcrypt.h>
#   pragma comment(lib, "bcrypt.lib")
#endif

#if defined(GATE_WIN32_ANSI)
#	include <stdlib.h>
#endif

typedef LONG(WINAPI* BCryptGenRandomProc)(PVOID hAlgorithm, PUCHAR pbBuffer, ULONG cbBuffer, ULONG dwFlags);

static BCryptGenRandomProc BCryptGenRandomImpl = NULL;

#ifndef STATUS_SUCCESS
#	define STATUS_SUCCESS ((LONG)0x00000000L)
#endif

#ifndef BCRYPT_RNG_USE_ENTROPY_IN_BUFFER
#	define BCRYPT_RNG_USE_ENTROPY_IN_BUFFER    0x00000001
#endif

#ifndef BCRYPT_USE_SYSTEM_PREFERRED_RNG
#	define BCRYPT_USE_SYSTEM_PREFERRED_RNG     0x00000002
#endif

static gate_bool_t load_bcrypt()
{
    static HMODULE hmod = NULL;
    LONG ntstatus;
    UCHAR test_buffer[sizeof(gate_uint32_t)];

    if (!BCryptGenRandomImpl)
    {
#if defined(GATE_SYS_WINSTORE)
        BCryptGenRandomImpl = &BCryptGenRandom;
#else
        if (!hmod)
        {
            hmod = gate_win32_load_library(_T("bcrypt.dll"), 0);
        }
        if (!hmod)
        {
            return false;
        }
        if (!gate_win32_get_proc_address(hmod, "BCryptGenRandom", &BCryptGenRandomImpl))
        {
            return false;
        }
#endif
    }

    ntstatus = BCryptGenRandomImpl(NULL, test_buffer, sizeof(test_buffer), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
    if (ntstatus != STATUS_SUCCESS)
    {
        return false;
    }

    return true;
}

#ifndef CRYPT_SILENT
#define CRYPT_SILENT 0x0040
#endif

gate_result_t gate_randomgenerator_create(gate_randomsession_t* session)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    HCRYPTPROV provider = 0;
    DWORD error_code;
    do
    {
        if (load_bcrypt())
        {
            *session = &BCryptGenRandomImpl;
            ret = GATE_RESULT_OK;
            break;
        }

#if defined(GATE_SYS_WINCE)
        if (!CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
        {
            error_code = GetLastError();
            GATE_DEBUG_TRACE_MSG_VALUE("CryptAcquireContext() failed", error_code);
            ret = GATE_RESULT_FAILED;
            break;
        }
#else
        if (!gate_platform.AdvCryptAcquireContext)
        {
            ret = GATE_RESULT_NOTSUPPORTED;
#	if defined(GATE_WIN32_ANSI)
            /*	WinNT 3 does not support Crypt API
                use CRT fallback */
            srand(GetTickCount());
            *session = NULL;
            ret = GATE_RESULT_OK;
#	endif	
            break;
        }
        if (!gate_platform.AdvCryptAcquireContext(&provider, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
        {
            /* Win9x has no SILENT flag */
            if (!gate_platform.AdvCryptAcquireContext(&provider, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
            {
                error_code = GetLastError();
                GATE_DEBUG_TRACE_MSG_VALUE("CryptAcquireContext() failed", error_code);
                ret = GATE_RESULT_FAILED;
                break;
            }
        }
#endif
        * session = (gate_randomsession_t)(gate_uintptr_t)provider;
        ret = GATE_RESULT_OK;
    } while (0);
    return ret;
}

union gate_randomgen_number
{
    gate_uint64_t	num;
    BYTE			buffer[sizeof(gate_uint64_t)];
    BYTE			dummy[32];
};

gate_result_t gate_randomgenerator_get_num(gate_randomsession_t* session, gate_uint64_t* number)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    union gate_randomgen_number tmp;

    ret = gate_randomgenerator_get_buffer(session, &tmp.buffer[0], sizeof(tmp.buffer));
    if (GATE_SUCCEEDED(ret))
    {
        *number = tmp.num;
    }
    return ret;
}
gate_result_t gate_randomgenerator_get_buffer(gate_randomsession_t* session, void* buffer, gate_size_t bufferlen)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    HCRYPTPROV hProv = (HCRYPTPROV)(gate_uintptr_t)*session;
    LONG ntstatus;
    BYTE* byte_buffer = (BYTE*)buffer;

    do
    {
        if (!session)
        {
            ret = GATE_RESULT_INVALIDARG;
            break;
        }
        if ((*session == &BCryptGenRandomImpl) && (BCryptGenRandomImpl != NULL))
        {
            ntstatus = BCryptGenRandomImpl(NULL, byte_buffer, (ULONG)bufferlen, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
            if (STATUS_SUCCESS == ntstatus)
            {
                ret = GATE_RESULT_OK;
            }
            else
            {
                ret = GATE_RESULT_FAILED;
            }
            break;
        }

#if defined(GATE_SYS_WINCE)
        if (!CryptGenRandom(hProv, (DWORD)bufferlen, byte_buffer))
        {
            ret = GATE_RESULT_FAILED;
            break;
        }
#else
        if (!gate_platform.AdvCryptGenRandom)
        {
            ret = GATE_RESULT_NOTSUPPORTED;
#	if defined(GATE_WIN32_ANSI)
            /* CRT fallback: */
            while (bufferlen-- > 0)
            {
                *byte_buffer = (BYTE)(rand() % 256);
                ++byte_buffer;
            }
            ret = GATE_RESULT_OK;
#	endif
            break;
        }
        if (!gate_platform.AdvCryptGenRandom(hProv, (DWORD)bufferlen, byte_buffer))
        {
            ret = GATE_RESULT_FAILED;
            break;
        }
#endif
        ret = GATE_RESULT_OK;
    } while (0);
    return ret;
}

gate_result_t gate_randomgenerator_destroy(gate_randomsession_t* session)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    HCRYPTPROV hProv;

    do
    {
        if (!session)
        {
            ret = GATE_RESULT_INVALIDARG;
            break;
        }
        if (*session == &BCryptGenRandomImpl)
        {
            /* nothing to release */
            ret = GATE_RESULT_OK;
            break;
        }

        hProv = (HCRYPTPROV)(gate_uintptr_t)*session;
        if (hProv)
        {
#if defined(GATE_SYS_WINCE)
            if (!CryptReleaseContext(hProv, 0))
            {
                ret = GATE_RESULT_FAILED;
            }
#else
            if (!gate_platform.AdvCryptReleaseContext)
            {
                ret = GATE_RESULT_NOTSUPPORTED;
                break;
            }
            if (!gate_platform.AdvCryptReleaseContext(hProv, 0))
            {
                ret = GATE_RESULT_FAILED;<--- Variable 'ret' is reassigned a value before the old one has been used.
            }
#endif
        }
        *session = NULL;
        ret = GATE_RESULT_OK;<--- Variable 'ret' is reassigned a value before the old one has been used.
    } while (0);

    return ret;
}


#endif	/* GATE_CORE_RANDOM_WINAPI_IMPL */



#if defined(GATE_CORE_RANDOM_POSIX_IMPL)

#include "gate/platforms.h"
#include <fcntl.h>

gate_result_t gate_randomgenerator_create(gate_randomsession_t* session)
{
    int file = open("/dev/random", O_RDONLY, 0);
    if (file == -1)
    {
        return GATE_RESULT_FAILED;
    }
    else
    {
        *session = (gate_randomsession_t)(gate_intptr_t)file;
        return GATE_RESULT_OK;
    }
}

union gate_randomgen_number
{
    gate_uint64_t	num;
    char			buffer[sizeof(gate_uint64_t)];
};

gate_result_t gate_randomgenerator_get_num(gate_randomsession_t* session, gate_uint64_t* number)
{
    int file = (int)(gate_intptr_t)*session;<--- Assigning a pointer to an integer is not portable. [+]Assigning a pointer to an integer (int/long/etc) is not portable across different platforms and compilers. For example in 32-bit Windows and linux they are same width, but in 64-bit Windows and linux they are of different width. In worst case you end up assigning 64-bit address to 32-bit integer. The safe way is to store addresses only in pointer types (or typedefs like uintptr_t).
    union gate_randomgen_number tmp;
    gate_size_t count = 0;
    ssize_t readresult;<--- The scope of the variable 'readresult' can be reduced. [+]The scope of the variable 'readresult' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    while (count < sizeof(tmp.buffer))
    {
        readresult = read(file, &tmp.buffer[count], sizeof(tmp.buffer) - count);
        if (readresult == -1)
        {
            return GATE_RESULT_FAILED;
        }
        count += (gate_size_t)readresult;
    }

    *number = tmp.num;
    return GATE_RESULT_OK;
}
gate_result_t gate_randomgenerator_get_buffer(gate_randomsession_t* session, void* buffer, gate_size_t bufferlen)
{
    int file = (int)(gate_intptr_t)*session;<--- Assigning a pointer to an integer is not portable. [+]Assigning a pointer to an integer (int/long/etc) is not portable across different platforms and compilers. For example in 32-bit Windows and linux they are same width, but in 64-bit Windows and linux they are of different width. In worst case you end up assigning 64-bit address to 32-bit integer. The safe way is to store addresses only in pointer types (or typedefs like uintptr_t).
    char* ptr = (char*)buffer;
    gate_size_t count = 0;
    ssize_t readresult;<--- The scope of the variable 'readresult' can be reduced. [+]The scope of the variable 'readresult' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    while (count < bufferlen)
    {
        readresult = read(file, &ptr[count], bufferlen - count);
        if (readresult == -1)
        {
            return GATE_RESULT_FAILED;
        }
        count += (gate_size_t)readresult;
    }
    return GATE_RESULT_OK;
}

gate_result_t gate_randomgenerator_destroy(gate_randomsession_t* session)
{
    int file = (int)(gate_intptr_t)*session;<--- Assigning a pointer to an integer is not portable. [+]Assigning a pointer to an integer (int/long/etc) is not portable across different platforms and compilers. For example in 32-bit Windows and linux they are same width, but in 64-bit Windows and linux they are of different width. In worst case you end up assigning 64-bit address to 32-bit integer. The safe way is to store addresses only in pointer types (or typedefs like uintptr_t).
    if (-1 == close(file))
    {
        return GATE_RESULT_FAILED;
    }
    *session = NULL;
    return GATE_RESULT_OK;
}

#endif /* GATE_CORE_RANDOM_POSIX_IMPL */


#if defined(GATE_CORE_RANDOM_GATE_IMPL)

#include "gate/memalloc.h"
#include "gate/times.h"

/* GATE uses KISS from George Marsaglia's implementation */
/* http://www.cse.yorku.ca/~oz/marsaglia-rng.html */

typedef unsigned long rnd_num_t;

typedef struct
{
    rnd_num_t z;
    rnd_num_t w;
    rnd_num_t jsr;
    rnd_num_t jcong;
    rnd_num_t a;
    rnd_num_t b;
    rnd_num_t t[256];

    rnd_num_t x;
    rnd_num_t y;
    rnd_num_t bro;

    unsigned char c;

} gate_randomgen_impl_t;


static gate_randomgen_impl_t* get_global_random_impl()
{
#if defined(GATE_SYS_DOS) 
    static gate_randomgen_impl_t near global_random_impl;
#else
    static gate_randomgen_impl_t global_random_impl;
#endif
    return &global_random_impl;
}



static rnd_num_t random_znew(gate_randomgen_impl_t* impl)
{
    return (impl->z = 36969 * (impl->z & 65535) + (impl->z >> 16));
}
static rnd_num_t random_wnew(gate_randomgen_impl_t* impl)
{
    return (impl->w = 18000 * (impl->w & 65535) + (impl->w >> 16));
}
static rnd_num_t random_MWC(gate_randomgen_impl_t* impl)
{
    return ((random_znew(impl) << 16) + random_wnew(impl));
}
static rnd_num_t random_CONG(gate_randomgen_impl_t* impl)
{
    return (impl->jcong = 69069 * impl->jcong + 1234567);
}
static rnd_num_t random_SHR3(gate_randomgen_impl_t* impl)
{
    return (impl->jsr ^= (impl->jsr << 17), impl->jsr ^= (impl->jsr >> 13), impl->jsr ^= (impl->jsr << 5));
}
static rnd_num_t random_KISS(gate_randomgen_impl_t* impl)
{
    return ((random_MWC(impl) ^ random_CONG(impl)) + random_SHR3(impl));
}
static rnd_num_t random_LFIB4(gate_randomgen_impl_t* impl)
{
    return (impl->c++,
        impl->t[impl->c] = impl->t[impl->c]
        + impl->t[(unsigned char)(impl->c + 58)]
        + impl->t[(unsigned char)(impl->c + 119)]
        + impl->t[(unsigned char)(impl->c + 178)]
        );
}

static void random_init(gate_randomgen_impl_t* impl, unsigned long seed)
{
    unsigned int i;
    impl->z = 12345 + ((seed) | 0xff);
    impl->w = 65435 + ((seed >> 4) | 0xff);
    impl->jsr = 34221 + ((seed >> 8) | 0xff);
    impl->jcong = 12345 + ((seed >> 12) | 0xff);
    impl->a = 9983651 + ((seed >> 16) | 0xff);
    impl->b = 95746118 + ((seed >> 20) | 0xff);
    impl->x = 0;
    impl->y = 0;
    impl->bro = 0;
    impl->c = 0;

    for (i = 0; i != sizeof(impl->t) / sizeof(impl->t[0]); ++i)
    {
        impl->t[i] = random_KISS(impl);
    }
}

gate_result_t gate_randomgenerator_create(gate_randomsession_t* session)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_randomgen_impl_t* ptr_impl;
    gate_time_t tm = GATE_INIT_EMPTY;
    if (session)
    {
        ptr_impl = (gate_randomgen_impl_t*)gate_mem_alloc(sizeof(gate_randomgen_impl_t));
        if (ptr_impl == NULL)
        {
            ptr_impl = get_global_random_impl();
        }
        *session = (void*)ptr_impl;
    }
    else
    {
        ptr_impl = get_global_random_impl();
    }

    gate_time_now(&tm);
    random_init(ptr_impl, (unsigned long)(tm.timestamp & 0xffffffff));

    return ret;
}

gate_result_t gate_randomgenerator_get_num(gate_randomsession_t* session, gate_uint64_t* number)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_randomgen_impl_t* ptr_impl;
    gate_uint64_t num[4];
    if (session)
    {
        ptr_impl = (gate_randomgen_impl_t*)*session;
    }
    else
    {
        ptr_impl = get_global_random_impl();
    }
    num[0] = random_LFIB4(ptr_impl);
    num[1] = random_LFIB4(ptr_impl);
    num[2] = random_LFIB4(ptr_impl);
    num[3] = random_LFIB4(ptr_impl);

    if (number)
    {
        *number = (num[0] & 0xffff)
            | ((num[1] & 0xffff) << 16)
            | ((num[2] & 0xffff) << 32)
            | ((num[3] & 0xffff) << 48)
            ;
    }
    return ret;
}

gate_result_t gate_randomgenerator_get_buffer(gate_randomsession_t* session, void* buffer, gate_size_t bufferlen)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_randomgen_impl_t* ptr_impl;
    unsigned char* ptr_buffer = (unsigned char*)buffer;
    if (session)
    {
        ptr_impl = (gate_randomgen_impl_t*)*session;
    }
    else
    {
        ptr_impl = get_global_random_impl();
    }
    while (bufferlen-- != 0)
    {
        *ptr_buffer = (unsigned char)((random_LFIB4(ptr_impl) >> 4) & 0xff);
        ++ptr_buffer;
    }
    return ret;
}

gate_result_t gate_randomgenerator_destroy(gate_randomsession_t* session)
{
    gate_randomgen_impl_t* ptr_impl;<--- The scope of the variable 'ptr_impl' can be reduced. [+]The scope of the variable 'ptr_impl' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    if (session)
    {
        ptr_impl = (gate_randomgen_impl_t*)*session;
        if (ptr_impl && (ptr_impl != get_global_random_impl()))
        {
            gate_mem_dealloc(ptr_impl);
        }
    }
    return GATE_RESULT_OK;
}

#endif  /* GATE_CORE_RANDOM_GATE_IMPL */
Cppcheck report - GATE C/C++ Framework: gate/randomgen.c
