internal.h

Go to the documentation of this file.

#pragma once
#include <vector>
#include <array>
#include <thread>
#include <atomic>
#include <condition_variable>
#include <mutex>
#include <functional>
#include <type_traits>
#include "../../DCS_Utils/include/DCS_ModuleUtils.h"

#define DCS_SHA256_DIGEST_LENGTH 32

namespace DCS
{
    namespace Threading
    {
        struct DCS_INTERNAL_TEST TPool
        {
            std::vector<std::thread> workers;
            std::mutex lock;
            std::condition_variable signal;
            std::array<std::atomic_int, 16> flags;
        };

        DCS_INTERNAL_TEST TPool* CreatePersistentPool(u16 size, std::vector<std::function<void(std::mutex*, std::condition_variable*, std::array<std::atomic_int, 16>*)>> workers);

        DCS_INTERNAL_TEST void JoinPool(TPool* pool);

        DCS_INTERNAL_TEST u64 GetPoolWorkCount(TPool* pool);

        DCS_INTERNAL_TEST void DestroyPool(TPool* pool);
    }

    namespace DB // TODO : Add user login statistics / trace
    {
#pragma pack( push )
        // NOTE : Using a salt is nice but requires to send the plain text password which is okay but such security is not needed.
        // Just ensure the user has a strong password.

        struct User
        {
            char u[32]; 
            u8   p[32]; 
        };
#pragma pack( pop )

        DCS_INTERNAL_TEST void LoadDefaultDB();

        DCS_INTERNAL_TEST void CloseDB();

        DCS_INTERNAL_TEST void LoadUsers();

        DCS_INTERNAL_TEST void AddUser(const char* username, const char* password);

        DCS_INTERNAL_TEST void RemoveUserByUsername(const char* username);

        DCS_INTERNAL_TEST u64  FindUserByUsername(const char* username);

        DCS_INTERNAL_TEST User GetUser(const char* username);

        DCS_INTERNAL_TEST const User* GetAllUsers();

        DCS_INTERNAL_TEST u64  GetUserCount();
    }

    namespace Auth
    {
        DCS_INTERNAL_TEST void InitCryptoRand();

        DCS_INTERNAL_TEST void GenerateSalt(DCS::u8 salt[8]);

        DCS_INTERNAL_TEST void GenerateRandSafeIV128(DCS::u8 iv[16]);

        DCS_INTERNAL_TEST void SHA256Str(const char* string, DCS::u8 hash[DCS_SHA256_DIGEST_LENGTH]);

        DCS_INTERNAL_TEST void HexStringifyBytes(char* out, DCS::u8* hash, DCS::u64 size);

        DCS_INTERNAL_TEST void EncryptAES256(DCS::u8* to_encrypt, int to_encrypt_size, 
                                             DCS::u8* aad, int aad_size, DCS::u8* key, 
                                             DCS::u8* iv, DCS::u8* encrypted_out, DCS::u8* tag);

        DCS_INTERNAL_TEST int  DecryptAES256(DCS::u8* cipher, int cipher_size, 
                                             DCS::u8* aad, int aad_size, DCS::u8* key, 
                                             DCS::u8* iv, DCS::u8* plain_out, DCS::u8* tag);
    }

    namespace Core // NOTE : Might deprecate this (using external firmware)
    {
        class DCS_INTERNAL_TEST PID
        {
        public:
            PID(float min, float max, float Kp, float Kd, float Ki);

            void setTargetAndBias(float target, float bias);

            float calculate(float value);

            float calculate(float value, float dt);

        private:
            float min;
            float max;
            float Kp;
            float Kd;
            float Ki;

            float dt;

            float target;
            float bias;

            float le;
            float integral;

            std::chrono::steady_clock::time_point last_point;
        };
    }
}