system.h

Go to the documentation of this file.

/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
/* If you are missing that file, acquire a complete release at teeworlds.com.                */
 
/*
    Title: OS Abstraction
*/
 
#ifndef BASE_SYSTEM_H
#define BASE_SYSTEM_H
 
#include "detect.h"
#include "types.h"
 
#ifndef __USE_GNU
#define __USE_GNU
#endif
 
#include <chrono>
#include <cinttypes>
#include <cstdarg>
#include <cstdint>
#include <cstring>
#include <ctime>
#include <functional>
#include <mutex>
#include <optional>
#include <string>
 
#ifdef __MINGW32__
#undef PRId64
#undef PRIu64
#undef PRIX64
#define PRId64 "I64d"
#define PRIu64 "I64u"
#define PRIX64 "I64X"
#define PRIzu "Iu"
#else
#define PRIzu "zu"
#endif
 
#ifdef CONF_FAMILY_UNIX
#include <sys/un.h>
#endif
 
#ifdef CONF_PLATFORM_LINUX
#include <netinet/in.h>
#include <sys/socket.h>
#endif
 
#if __cplusplus >= 201703L
#define MAYBE_UNUSED [[maybe_unused]]
#elif defined(__GNUC__)
#define MAYBE_UNUSED __attribute__((unused))
#else
#define MAYBE_UNUSED
#endif
 
#ifdef __GNUC__
#define GNUC_ATTRIBUTE(x) __attribute__(x)
#else
#define GNUC_ATTRIBUTE(x)
#endif
 
#define dbg_assert(test, fmt, ...) \
    do \
    { \
        if(!(test)) \
        { \
            dbg_assert_imp(__FILE__, __LINE__, fmt, ##__VA_ARGS__); \
        } \
    } while(false)
 
#if defined(__cplusplus)
[[noreturn]]
#endif
void
dbg_assert_imp(const char *filename, int line, const char *fmt, ...)
    GNUC_ATTRIBUTE((format(printf, 3, 4)));
 
#ifdef __clang_analyzer__
#include <cassert>
#undef dbg_assert
#define dbg_assert(test, fmt, ...) assert(test)
#endif
 
bool dbg_assert_has_failed();
 
#if defined(__cplusplus)
[[noreturn]]
#endif
void
dbg_break();
 
typedef std::function<void(const char *message)> DBG_ASSERT_HANDLER;
void dbg_assert_set_handler(DBG_ASSERT_HANDLER handler);
 
void dbg_msg(const char *sys, const char *fmt, ...)
    GNUC_ATTRIBUTE((format(printf, 2, 3)));
 
void mem_copy(void *dest, const void *source, size_t size);
 
void mem_move(void *dest, const void *source, size_t size);
 
template<typename T>
inline void mem_zero(T *block, size_t size)
{
    static_assert((std::is_trivially_constructible<T>::value && std::is_trivially_destructible<T>::value) || std::is_fundamental<T>::value);
    memset(block, 0, size);
}
 
int mem_comp(const void *a, const void *b, size_t size);
 
bool mem_has_null(const void *block, size_t size);
 
enum
{
    IOFLAG_READ = 1,
    IOFLAG_WRITE = 2,
    IOFLAG_APPEND = 4,
};
 
enum ESeekOrigin
{
    IOSEEK_START = 0,
    IOSEEK_CUR = 1,
    IOSEEK_END = 2,
};
 
IOHANDLE io_open(const char *filename, int flags);
 
unsigned io_read(IOHANDLE io, void *buffer, unsigned size);
 
bool io_read_all(IOHANDLE io, void **result, unsigned *result_len);
 
char *io_read_all_str(IOHANDLE io);
 
int io_skip(IOHANDLE io, int64_t size);
 
int io_seek(IOHANDLE io, int64_t offset, ESeekOrigin origin);
 
int64_t io_tell(IOHANDLE io);
 
int64_t io_length(IOHANDLE io);
 
unsigned io_write(IOHANDLE io, const void *buffer, unsigned size);
 
bool io_write_newline(IOHANDLE io);
 
int io_close(IOHANDLE io);
 
int io_flush(IOHANDLE io);
 
int io_sync(IOHANDLE io);
 
int io_error(IOHANDLE io);
 
IOHANDLE io_stdin();
 
IOHANDLE io_stdout();
 
IOHANDLE io_stderr();
 
IOHANDLE io_current_exe();
 
typedef struct ASYNCIO ASYNCIO;
 
ASYNCIO *aio_new(IOHANDLE io);
 
void aio_lock(ASYNCIO *aio);
 
void aio_unlock(ASYNCIO *aio);
 
void aio_write(ASYNCIO *aio, const void *buffer, unsigned size);
 
void aio_write_newline(ASYNCIO *aio);
 
void aio_write_unlocked(ASYNCIO *aio, const void *buffer, unsigned size);
 
void aio_write_newline_unlocked(ASYNCIO *aio);
 
int aio_error(ASYNCIO *aio);
 
void aio_close(ASYNCIO *aio);
 
void aio_wait(ASYNCIO *aio);
 
void aio_free(ASYNCIO *aio);
 
void *thread_init(void (*threadfunc)(void *), void *user, const char *name);
 
void thread_wait(void *thread);
 
void thread_yield();
 
void thread_detach(void *thread);
 
void thread_init_and_detach(void (*threadfunc)(void *), void *user, const char *name);
 
#if defined(CONF_FAMILY_WINDOWS)
typedef void *SEMAPHORE;
#elif defined(CONF_PLATFORM_MACOS)
#include <semaphore.h>
typedef sem_t *SEMAPHORE;
#elif defined(CONF_FAMILY_UNIX)
#include <semaphore.h>
typedef sem_t SEMAPHORE;
#else
#error not implemented on this platform
#endif
 
void sphore_init(SEMAPHORE *sem);
void sphore_wait(SEMAPHORE *sem);
void sphore_signal(SEMAPHORE *sem);
void sphore_destroy(SEMAPHORE *sem);
 
void set_new_tick();
 
int64_t time_get_impl();
 
int64_t time_get();
 
int64_t time_freq();
 
int64_t time_timestamp();
 
int time_houroftheday();
 
enum ETimeSeason
{
    SEASON_SPRING = 0,
    SEASON_SUMMER,
    SEASON_AUTUMN,
    SEASON_WINTER,
    SEASON_EASTER,
    SEASON_HALLOWEEN,
    SEASON_XMAS,
    SEASON_NEWYEAR
};
 
ETimeSeason time_season();
 
extern const NETADDR NETADDR_ZEROED;
 
#ifdef CONF_FAMILY_UNIX
typedef int UNIXSOCKET;
typedef struct sockaddr_un UNIXSOCKETADDR;
#endif
 
void net_init();
 
/*
    Function: net_host_lookup
        Does a hostname lookup by name and fills out the passed
        NETADDR struct with the received details.
 
    Returns:
        0 on success.
*/
int net_host_lookup(const char *hostname, NETADDR *addr, int types);
 
int net_addr_comp(const NETADDR *a, const NETADDR *b);
 
int net_addr_comp_noport(const NETADDR *a, const NETADDR *b);
 
void net_addr_str(const NETADDR *addr, char *string, int max_length, bool add_port);
 
int net_addr_from_url(NETADDR *addr, const char *string, char *host_buf, size_t host_buf_size);
 
bool net_addr_is_local(const NETADDR *addr);
 
int net_addr_from_str(NETADDR *addr, const char *string);
 
/*
    Function: net_socket_type
        Determine a socket's type.
 
    Parameters:
        sock - Socket whose type should be determined.
 
    Returns:
        The socket type, a bitset of `NETTYPE_IPV4`, `NETTYPE_IPV6` and
        `NETTYPE_WEBSOCKET_IPV4`.
*/
int net_socket_type(NETSOCKET sock);
 
/*
    Function: net_udp_create
        Creates a UDP socket and binds it to a port.
 
    Parameters:
        bindaddr - Address to bind the socket to.
 
    Returns:
        On success it returns an handle to the socket. On failure it
        returns NETSOCKET_INVALID.
*/
NETSOCKET net_udp_create(NETADDR bindaddr);
 
int net_udp_send(NETSOCKET sock, const NETADDR *addr, const void *data, int size);
 
/*
    Function: net_udp_recv
        Receives a packet over an UDP socket.
 
    Parameters:
        sock - Socket to use.
        addr - Pointer to an NETADDR that will receive the address.
        data - Received data. Will be invalidated when this function is
        called again.
 
    Returns:
        On success it returns the number of bytes received. Returns -1
        on error.
*/
int net_udp_recv(NETSOCKET sock, NETADDR *addr, unsigned char **data);
 
int net_udp_close(NETSOCKET sock);
 
NETSOCKET net_tcp_create(NETADDR bindaddr);
 
int net_tcp_listen(NETSOCKET sock, int backlog);
 
int net_tcp_accept(NETSOCKET sock, NETSOCKET *new_sock, NETADDR *addr);
 
int net_tcp_connect(NETSOCKET sock, const NETADDR *addr);
 
int net_tcp_send(NETSOCKET sock, const void *data, int size);
 
int net_tcp_recv(NETSOCKET sock, void *data, int maxsize);
 
int net_tcp_close(NETSOCKET sock);
 
#if defined(CONF_FAMILY_UNIX)
UNIXSOCKET net_unix_create_unnamed();
 
int net_unix_send(UNIXSOCKET sock, UNIXSOCKETADDR *addr, void *data, int size);
 
void net_unix_set_addr(UNIXSOCKETADDR *addr, const char *path);
 
void net_unix_close(UNIXSOCKET sock);
 
#elif defined(CONF_FAMILY_WINDOWS)
 
std::string windows_format_system_message(unsigned long error);
 
#endif
 
void str_append(char *dst, const char *src, int dst_size);
 
template<int N>
void str_append(char (&dst)[N], const char *src)
{
    str_append(dst, src, N);
}
 
int str_copy(char *dst, const char *src, int dst_size);
 
template<int N>
void str_copy(char (&dst)[N], const char *src)
{
    str_copy(dst, src, N);
}
 
void str_utf8_truncate(char *dst, int dst_size, const char *src, int truncation_len);
 
void str_truncate(char *dst, int dst_size, const char *src, int truncation_len);
 
int str_length(const char *str);
 
int str_format_v(char *buffer, int buffer_size, const char *format, va_list args)
    GNUC_ATTRIBUTE((format(printf, 3, 0)));
 
int str_format(char *buffer, int buffer_size, const char *format, ...)
    GNUC_ATTRIBUTE((format(printf, 3, 4)));
 
#if !defined(CONF_DEBUG)
int str_format_int(char *buffer, size_t buffer_size, int value);
 
template<typename... Args>
int str_format_opt(char *buffer, int buffer_size, const char *format, Args... args)
{
    static_assert(sizeof...(args) > 0, "Use str_copy instead of str_format without format arguments");
    return str_format(buffer, buffer_size, format, args...);
}
 
template<>
inline int str_format_opt(char *buffer, int buffer_size, const char *format, int val)
{
    if(strcmp(format, "%d") == 0)
    {
        return str_format_int(buffer, buffer_size, val);
    }
    else
    {
        return str_format(buffer, buffer_size, format, val);
    }
}
 
#define str_format str_format_opt
#endif
 
const char *str_trim_words(const char *str, int words);
 
bool str_has_cc(const char *str);
 
void str_sanitize_cc(char *str);
 
void str_sanitize(char *str);
 
void str_sanitize_filename(char *str);
 
void str_clean_whitespaces(char *str);
 
char *str_skip_to_whitespace(char *str);
 
const char *str_skip_to_whitespace_const(const char *str);
 
char *str_skip_whitespaces(char *str);
 
const char *str_skip_whitespaces_const(const char *str);
 
int str_comp_nocase(const char *a, const char *b);
 
int str_comp_nocase_num(const char *a, const char *b, int num);
 
int str_comp(const char *a, const char *b);
 
int str_comp_num(const char *a, const char *b, int num);
 
int str_comp_filenames(const char *a, const char *b);
 
/*
       Function: str_startswith_nocase
               Checks case insensitive whether the string begins with a certain prefix.
 
       Parameter:
               str - String to check.
               prefix - Prefix to look for.
 
       Returns:
               A pointer to the string str after the string prefix, or 0 if
               the string prefix isn't a prefix of the string str.
 
       Remarks:
               - The strings are treated as zero-terminated strings.
*/
const char *str_startswith_nocase(const char *str, const char *prefix);
 
const char *str_startswith(const char *str, const char *prefix);
 
/*
       Function: str_endswith_nocase
               Checks case insensitive whether the string ends with a certain suffix.
 
       Parameter:
               str - String to check.
               suffix - Suffix to look for.
 
       Returns:
               A pointer to the beginning of the suffix in the string str, or
               0 if the string suffix isn't a suffix of the string str.
 
       Remarks:
               - The strings are treated as zero-terminated strings.
*/
const char *str_endswith_nocase(const char *str, const char *suffix);
 
/*
    Function: str_endswith
        Checks case sensitive whether the string ends with a certain suffix.
 
    Parameter:
        str - String to check.
        suffix - Suffix to look for.
 
    Returns:
        A pointer to the beginning of the suffix in the string str, or
        0 if the string suffix isn't a suffix of the string str.
 
    Remarks:
        - The strings are treated as zero-terminated strings.
*/
const char *str_endswith(const char *str, const char *suffix);
 
int str_utf8_dist(const char *a, const char *b);
 
int str_utf8_dist_buffer(const char *a, const char *b, int *buf, int buf_len);
 
/*
    Function: str_utf32_dist_buffer
        Computes the edit distance between two strings, allows buffers
        to be passed in.
 
    Parameters:
        a - First string for the edit distance.
        a_len - Length of the first string.
        b - Second string for the edit distance.
        b_len - Length of the second string.
        buf - Buffer for the function.
        buf_len - Length of the buffer, must be at least as long as
                  the length of both strings combined plus two.
 
    Returns:
        The edit distance between the both strings.
 
    Remarks:
        - The strings are treated as zero-terminated strings.
*/
int str_utf32_dist_buffer(const int *a, int a_len, const int *b, int b_len, int *buf, int buf_len);
 
/*
    Function: str_find_nocase
        Finds a string inside another string case insensitively.
 
    Parameters:
        haystack - String to search in
        needle - String to search for
 
    Returns:
        A pointer into haystack where the needle was found.
        Returns NULL if needle could not be found.
 
    Remarks:
        - Only guaranteed to work with a-z/A-Z.
          (use str_utf8_find_nocase for unicode support)
        - The strings are treated as zero-terminated strings.
*/
const char *str_find_nocase(const char *haystack, const char *needle);
 
/*
    Function: str_find
        Finds a string inside another string case sensitive.
 
    Parameters:
        haystack - String to search in
        needle - String to search for
 
    Returns:
        A pointer into haystack where the needle was found.
        Returns NULL if needle could not be found.
 
    Remarks:
        - The strings are treated as zero-terminated strings.
*/
const char *str_find(const char *haystack, const char *needle);
 
bool str_delimiters_around_offset(const char *haystay, const char *delim, int offset, int *start, int *end);
 
const char *str_rchr(const char *haystack, char needle);
 
int str_countchr(const char *haystack, char needle);
 
void str_hex(char *dst, int dst_size, const void *data, int data_size);
 
void str_hex_cstyle(char *dst, int dst_size, const void *data, int data_size, int bytes_per_line = 12);
 
/*
    Function: str_hex_decode
        Takes a hex string *without spaces between bytes* and returns a
        byte array.
 
    Parameters:
        dst - Buffer for the byte array
        dst_size - size of the buffer
        data - String to decode
 
    Returns:
        2 - String doesn't exactly fit the buffer
        1 - Invalid character in string
        0 - Success
 
    Remarks:
        - The contents of the buffer is only valid on success
*/
int str_hex_decode(void *dst, int dst_size, const char *src);
 
/*
    Function: str_base64
        Takes a datablock and generates the base64 encoding of it.
 
    Parameters:
        dst - Buffer to fill with base64 data
        dst_size - Size of the buffer
        data - Data to turn into base64
        data - Size of the data
 
    Remarks:
        - The destination buffer will be zero-terminated
*/
void str_base64(char *dst, int dst_size, const void *data, int data_size);
 
/*
    Function: str_base64_decode
        Takes a base64 string without any whitespace and correct
        padding and returns a byte array.
 
    Parameters:
        dst - Buffer for the byte array
        dst_size - Size of the buffer
        data - String to decode
 
    Returns:
        <0 - Error
        >= 0 - Success, length of the resulting byte buffer
 
    Remarks:
        - The contents of the buffer is only valid on success
*/
int str_base64_decode(void *dst, int dst_size, const char *data);
 
/*
    Function: str_timestamp
        Copies a time stamp in the format year-month-day_hour-minute-second to the string.
 
    Parameters:
        buffer - Pointer to a buffer that shall receive the time stamp string.
        buffer_size - Size of the buffer.
 
    Remarks:
        - Guarantees that buffer string will contain zero-termination.
*/
void str_timestamp(char *buffer, int buffer_size);
void str_timestamp_format(char *buffer, int buffer_size, const char *format)
    GNUC_ATTRIBUTE((format(strftime, 3, 0)));
void str_timestamp_ex(time_t time, char *buffer, int buffer_size, const char *format)
    GNUC_ATTRIBUTE((format(strftime, 4, 0)));
 
bool timestamp_from_str(const char *string, const char *format, time_t *timestamp)
    GNUC_ATTRIBUTE((format(strftime, 2, 0)));
 
#define FORMAT_TIME "%H:%M:%S"
#define FORMAT_SPACE "%Y-%m-%d %H:%M:%S"
#define FORMAT_NOSPACE "%Y-%m-%d_%H-%M-%S"
 
enum
{
    TIME_DAYS,
    TIME_HOURS,
    TIME_MINS,
    TIME_HOURS_CENTISECS,
    TIME_MINS_CENTISECS,
    TIME_SECS_CENTISECS,
};
 
/*
    Function: str_times
        Formats a time string.
 
    Parameters:
        centisecs - Time in centiseconds, minimum value clamped to 0
        format - Format of the time string, see enum above, for example TIME_DAYS
        buffer - Pointer to a buffer that shall receive the time stamp string.
        buffer_size - Size of the buffer.
 
    Returns:
        Number of bytes written, -1 on invalid format or buffer_size <= 0
 
    Remarks:
        - Guarantees that buffer string will contain zero-termination, assuming
          buffer_size > 0.
*/
int str_time(int64_t centisecs, int format, char *buffer, int buffer_size);
int str_time_float(float secs, int format, char *buffer, int buffer_size);
 
/*
    Function: str_escape
        Escapes \ and " characters in a string.
 
    Parameters:
        dst - Destination array pointer, gets increased, will point to
              the terminating null.
        src - Source array
        end - End of destination array
*/
void str_escape(char **dst, const char *src, const char *end);
 
void fs_listdir(const char *dir, FS_LISTDIR_CALLBACK cb, int type, void *user);
 
void fs_listdir_fileinfo(const char *dir, FS_LISTDIR_CALLBACK_FILEINFO cb, int type, void *user);
 
int fs_makedir(const char *path);
 
int fs_removedir(const char *path);
 
int fs_makedir_rec_for(const char *path);
 
int fs_storage_path(const char *appname, char *path, int max);
 
int fs_is_file(const char *path);
 
int fs_is_dir(const char *path);
 
int fs_is_relative_path(const char *path);
 
int fs_chdir(const char *path);
 
char *fs_getcwd(char *buffer, int buffer_size);
 
const char *fs_filename(const char *path);
 
void fs_split_file_extension(const char *filename, char *name, size_t name_size, char *extension = nullptr, size_t extension_size = 0);
 
int fs_parent_dir(char *path);
 
int fs_remove(const char *filename);
 
int fs_rename(const char *oldname, const char *newname);
 
int fs_file_time(const char *name, time_t *created, time_t *modified);
 
/*
    Group: Undocumented
*/
 
/*
    Function: net_tcp_connect_non_blocking
 
    DOCTODO: serp
*/
int net_tcp_connect_non_blocking(NETSOCKET sock, NETADDR bindaddr);
 
/*
    Function: net_set_non_blocking
 
    DOCTODO: serp
*/
int net_set_non_blocking(NETSOCKET sock);
 
/*
    Function: net_set_non_blocking
 
    DOCTODO: serp
*/
int net_set_blocking(NETSOCKET sock);
 
/*
    Function: net_errno
 
    DOCTODO: serp
*/
int net_errno();
 
/*
    Function: net_would_block
 
    DOCTODO: serp
*/
int net_would_block();
 
int net_socket_read_wait(NETSOCKET sock, int time);
 
void swap_endian(void *data, unsigned elem_size, unsigned num);
 
typedef struct
{
    uint64_t sent_packets;
    uint64_t sent_bytes;
    uint64_t recv_packets;
    uint64_t recv_bytes;
} NETSTATS;
 
void net_stats(NETSTATS *stats);
 
int str_toint(const char *str);
bool str_toint(const char *str, int *out);
int str_toint_base(const char *str, int base);
unsigned long str_toulong_base(const char *str, int base);
int64_t str_toint64_base(const char *str, int base = 10);
float str_tofloat(const char *str);
bool str_tofloat(const char *str, float *out);
 
int str_isspace(char c);
 
char str_uppercase(char c);
 
bool str_isnum(char c);
 
int str_isallnum(const char *str);
 
int str_isallnum_hex(const char *str);
 
unsigned str_quickhash(const char *str);
 
int str_utf8_to_skeleton(const char *str, int *buf, int buf_len);
 
/*
    Function: str_utf8_comp_confusable
        Compares two strings for visual appearance.
 
    Parameters:
        str1 - String to compare.
        str2 - String to compare.
 
    Returns:
        0 if the strings are confusable.
        !=0 otherwise.
*/
int str_utf8_comp_confusable(const char *str1, const char *str2);
 
/*
    Function: str_utf8_tolower
        Converts the given Unicode codepoint to lowercase (locale insensitive).
 
    Parameters:
        code - Unicode codepoint to convert.
 
    Returns:
        Lowercase codepoint
*/
int str_utf8_tolower(int code);
 
/*
    Function: str_utf8_comp_nocase
        Compares two utf8 strings case insensitively.
 
    Parameters:
        a - String to compare.
        b - String to compare.
 
    Returns:
        <0 - String a is less than string b
        0 - String a is equal to string b
        >0 - String a is greater than string b
*/
int str_utf8_comp_nocase(const char *a, const char *b);
 
/*
    Function: str_utf8_comp_nocase_num
        Compares up to num bytes of two utf8 strings case insensitively.
 
    Parameters:
        a - String to compare.
        b - String to compare.
        num - Maximum bytes to compare
 
    Returns:
        <0 - String a is less than string b
        0 - String a is equal to string b
        >0 - String a is greater than string b
*/
int str_utf8_comp_nocase_num(const char *a, const char *b, int num);
 
/*
    Function: str_utf8_find_nocase
        Finds a utf8 string inside another utf8 string case insensitively.
 
    Parameters:
        haystack - String to search in
        needle - String to search for
        end - A pointer that will be set to a pointer into haystack directly behind the
            last character where the needle was found. Will be set to nullptr if needle
            could not be found. Optional parameter.
 
    Returns:
        A pointer into haystack where the needle was found.
        Returns NULL if needle could not be found.
 
    Remarks:
        - The strings are treated as zero-terminated strings.
*/
const char *str_utf8_find_nocase(const char *haystack, const char *needle, const char **end = nullptr);
 
/*
    Function: str_utf8_isspace
        Checks whether the given Unicode codepoint renders as space.
 
    Parameters:
        code - Unicode codepoint to check.
 
    Returns:
        0 if the codepoint does not render as space, != 0 if it does.
*/
int str_utf8_isspace(int code);
 
int str_utf8_isstart(char c);
 
/*
    Function: str_utf8_skip_whitespaces
        Skips leading characters that render as spaces.
 
    Parameters:
        str - Pointer to the string.
 
    Returns:
        Pointer to the first non-whitespace character found
        within the string.
 
    Remarks:
        - The strings are treated as zero-terminated strings.
*/
const char *str_utf8_skip_whitespaces(const char *str);
 
/*
    Function: str_utf8_trim_right
        Removes trailing characters that render as spaces by modifying
        the string in-place.
 
    Parameters:
        param - Pointer to the string.
 
    Remarks:
        - The strings are treated as zero-terminated strings.
        - The string is modified in-place.
*/
void str_utf8_trim_right(char *param);
 
/*
    Function: str_utf8_rewind
        Moves a cursor backwards in an utf8 string
 
    Parameters:
        str - utf8 string
        cursor - position in the string
 
    Returns:
        New cursor position.
 
    Remarks:
        - Won't move the cursor less then 0
*/
int str_utf8_rewind(const char *str, int cursor);
 
/*
    Function: str_utf8_fix_truncation
        Fixes truncation of a Unicode character at the end of a UTF-8
        string.
 
    Returns:
        The new string length.
 
    Parameters:
        str - utf8 string
*/
int str_utf8_fix_truncation(char *str);
 
/*
    Function: str_utf8_forward
        Moves a cursor forwards in an utf8 string
 
    Parameters:
        str - utf8 string
        cursor - position in the string
 
    Returns:
        New cursor position.
 
    Remarks:
        - Won't move the cursor beyond the zero termination marker
*/
int str_utf8_forward(const char *str, int cursor);
 
/*
    Function: str_utf8_decode
        Decodes a utf8 codepoint
 
    Parameters:
        ptr - Pointer to a utf8 string. This pointer will be moved forward.
 
    Returns:
        The Unicode codepoint. -1 for invalid input and 0 for end of string.
 
    Remarks:
        - This function will also move the pointer forward.
        - You may call this function again after an error occurred.
*/
int str_utf8_decode(const char **ptr);
 
/*
    Function: str_utf8_encode
        Encode an utf8 character
 
    Parameters:
        ptr - Pointer to a buffer that should receive the data. Should be able to hold at least 4 bytes.
 
    Returns:
        Number of bytes put into the buffer.
 
    Remarks:
        - Does not do zero termination of the string.
*/
int str_utf8_encode(char *ptr, int chr);
 
/*
    Function: str_utf8_check
        Checks if a strings contains just valid utf8 characters.
 
    Parameters:
        str - Pointer to a possible utf8 string.
 
    Returns:
        0 - invalid characters found.
        1 - only valid characters found.
 
    Remarks:
        - The string is treated as zero-terminated utf8 string.
*/
int str_utf8_check(const char *str);
 
/*
    Function: str_utf8_copy_num
        Copies a number of utf8 characters from one string to another.
 
    Parameters:
        dst - Pointer to a buffer that shall receive the string.
        src - String to be copied.
        dst_size - Size of the buffer dst.
        num - maximum number of utf8 characters to be copied.
 
    Remarks:
        - The strings are treated as zero-terminated strings.
        - Garantees that dst string will contain zero-termination.
*/
void str_utf8_copy_num(char *dst, const char *src, int dst_size, int num);
 
/*
    Function: str_utf8_stats
        Determines the byte size and utf8 character count of a utf8 string.
 
    Parameters:
        str - Pointer to the string.
        max_size - Maximum number of bytes to count.
        max_count - Maximum number of utf8 characters to count.
        size - Pointer to store size (number of non-zero bytes) of the string.
        count - Pointer to store count of utf8 characters of the string.
 
    Remarks:
        - The string is treated as zero-terminated utf8 string.
        - It's the user's responsibility to make sure the bounds are aligned.
*/
void str_utf8_stats(const char *str, size_t max_size, size_t max_count, size_t *size, size_t *count);
 
size_t str_utf8_offset_bytes_to_chars(const char *str, size_t byte_offset);
 
size_t str_utf8_offset_chars_to_bytes(const char *str, size_t char_offset);
 
/*
    Function: str_next_token
        Writes the next token after str into buf, returns the rest of the string.
 
    Parameters:
        str - Pointer to string.
        delim - Delimiter for tokenization.
        buffer - Buffer to store token in.
        buffer_size - Size of the buffer.
 
    Returns:
        Pointer to rest of the string.
 
    Remarks:
        - The token is always null-terminated.
*/
const char *str_next_token(const char *str, const char *delim, char *buffer, int buffer_size);
 
/*
    Function: str_in_list
        Checks if needle is in list delimited by delim
 
    Parameters:
        list - List
        delim - List delimiter.
        needle - Item that is being looked for.
 
    Returns:
        1 - Item is in list.
        0 - Item isn't in list.
*/
int str_in_list(const char *list, const char *delim, const char *needle);
 
unsigned bytes_be_to_uint(const unsigned char *bytes);
 
void uint_to_bytes_be(unsigned char *bytes, unsigned value);
 
int pid();
 
void cmdline_fix(int *argc, const char ***argv);
 
void cmdline_free(int argc, const char **argv);
 
#if defined(CONF_FAMILY_WINDOWS)
typedef void *PROCESS;
constexpr PROCESS INVALID_PROCESS = nullptr;
#else
typedef pid_t PROCESS;
constexpr PROCESS INVALID_PROCESS = 0;
#endif
#if !defined(CONF_PLATFORM_ANDROID)
enum class EShellExecuteWindowState
{
    FOREGROUND,
 
    BACKGROUND,
};
 
#if defined(CONF_FAMILY_WINDOWS)
std::wstring windows_args_to_wide(const char **arguments, const size_t num_arguments);
#endif
 
PROCESS shell_execute(const char *file, EShellExecuteWindowState window_state, const char **arguments = nullptr, const size_t num_arguments = 0);
 
int kill_process(PROCESS process);
 
bool is_process_alive(PROCESS process);
 
int open_link(const char *link);
 
int open_file(const char *path);
#endif // !defined(CONF_PLATFORM_ANDROID)
 
void generate_password(char *buffer, unsigned length, const unsigned short *random, unsigned random_length);
 
[[nodiscard]] int secure_random_init();
 
int secure_random_uninit();
 
void secure_random_password(char *buffer, unsigned length, unsigned pw_length);
 
void secure_random_fill(void *bytes, unsigned length);
 
int secure_rand();
 
int secure_rand_below(int below);
 
bool os_version_str(char *version, size_t length);
 
void os_locale_str(char *locale, size_t length);
 
#if defined(CONF_EXCEPTION_HANDLING)
void init_exception_handler();
 
void set_exception_handler_log_file(const char *log_file_path);
#endif
 
std::chrono::nanoseconds time_get_nanoseconds();
 
int net_socket_read_wait(NETSOCKET sock, std::chrono::nanoseconds nanoseconds);
 
class CCmdlineFix
{
    int m_Argc;
    const char **m_ppArgv;
 
public:
    CCmdlineFix(int *pArgc, const char ***pppArgv)
    {
        cmdline_fix(pArgc, pppArgv);
        m_Argc = *pArgc;
        m_ppArgv = *pppArgv;
    }
    ~CCmdlineFix()
    {
        cmdline_free(m_Argc, m_ppArgv);
    }
};
 
#if defined(CONF_FAMILY_WINDOWS)
std::wstring windows_utf8_to_wide(const char *str);
 
std::optional<std::string> windows_wide_to_utf8(const wchar_t *wide_str);
 
class CWindowsComLifecycle
{
public:
    CWindowsComLifecycle(bool HasWindow);
    ~CWindowsComLifecycle();
};
 
bool shell_register_protocol(const char *protocol_name, const char *executable, bool *updated);
 
bool shell_register_extension(const char *extension, const char *description, const char *executable_name, const char *executable, bool *updated);
 
bool shell_register_application(const char *name, const char *executable, bool *updated);
 
bool shell_unregister_class(const char *shell_class, bool *updated);
 
bool shell_unregister_application(const char *executable, bool *updated);
 
void shell_update();
#endif
 
template<>
struct std::hash<NETADDR>
{
    size_t operator()(const NETADDR &Addr) const noexcept;
};
 
#endif