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"
 
#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
 
#define dbg_assert(test, fmt, ...) \
    do \
    { \
        if(!(test)) \
        { \
            dbg_assert_imp(__FILE__, __LINE__, fmt, ##__VA_ARGS__); \
        } \
    } while(false)
 
[[gnu::format(printf, 3, 4)]]
[[noreturn]] void
dbg_assert_imp(const char *filename, int line, const char *fmt, ...);
 
bool dbg_assert_has_failed();
 
[[noreturn]] void dbg_break();
 
typedef std::function<void(const char *message)> DBG_ASSERT_HANDLER;
void dbg_assert_set_handler(DBG_ASSERT_HANDLER handler);
 
[[gnu::format(printf, 2, 3)]] void dbg_msg(const char *sys, const char *fmt, ...);
 
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();
 
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);
 
int net_set_non_blocking(NETSOCKET sock);
 
int net_set_blocking(NETSOCKET sock);
 
int net_errno();
 
std::string net_error_message();
 
int net_would_block();
 
int net_socket_read_wait(NETSOCKET sock, std::chrono::nanoseconds nanoseconds);
 
int net_socket_type(NETSOCKET sock);
 
NETSOCKET net_udp_create(NETADDR bindaddr);
 
int net_udp_send(NETSOCKET sock, const NETADDR *addr, const void *data, int size);
 
int net_udp_recv(NETSOCKET sock, NETADDR *addr, unsigned char **data);
 
void 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_connect_non_blocking(NETSOCKET sock, NETADDR bindaddr);
 
int net_tcp_send(NETSOCKET sock, const void *data, int size);
 
int net_tcp_recv(NETSOCKET sock, void *data, int maxsize);
 
void 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);
 
[[gnu::format(printf, 3, 0)]] int str_format_v(char *buffer, int buffer_size, const char *format, va_list args);
 
[[gnu::format(printf, 3, 4)]] int str_format(char *buffer, int buffer_size, const char *format, ...);
 
#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);
 
bool str_valid_filename(const 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);
 
const char *str_startswith_nocase(const char *str, const char *prefix);
 
const char *str_startswith(const char *str, const char *prefix);
 
const char *str_endswith_nocase(const char *str, const char *suffix);
 
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);
 
int str_utf32_dist_buffer(const int *a, int a_len, const int *b, int b_len, int *buf, int buf_len);
 
const char *str_find_nocase(const char *haystack, const char *needle);
 
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);
 
int str_hex_decode(void *dst, int dst_size, const char *src);
 
void str_base64(char *dst, int dst_size, const void *data, int data_size);
 
int str_base64_decode(void *dst, int dst_size, const char *data);
 
void str_timestamp(char *buffer, int buffer_size);
[[gnu::format(strftime, 3, 0)]] void str_timestamp_format(char *buffer, int buffer_size, const char *format);
[[gnu::format(strftime, 4, 0)]] void str_timestamp_ex(time_t time, char *buffer, int buffer_size, const char *format);
 
[[gnu::format(strftime, 2, 0)]] bool timestamp_from_str(const char *string, const char *format, time_t *timestamp);
 
#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,
};
 
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);
 
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);
 
void fs_normalize_path(char *path);
 
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);
 
void swap_endian(void *data, unsigned elem_size, unsigned num);
 
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);
 
int str_utf8_comp_confusable(const char *str1, const char *str2);
 
int str_utf8_tolower_codepoint(int code);
 
void str_utf8_tolower(const char *input, char *output, size_t size);
 
int str_utf8_comp_nocase(const char *a, const char *b);
 
int str_utf8_comp_nocase_num(const char *a, const char *b, int num);
 
const char *str_utf8_find_nocase(const char *haystack, const char *needle, const char **end = nullptr);
 
int str_utf8_isspace(int code);
 
int str_utf8_isstart(char c);
 
const char *str_utf8_skip_whitespaces(const char *str);
 
void str_utf8_trim_right(char *param);
 
int str_utf8_rewind(const char *str, int cursor);
 
int str_utf8_fix_truncation(char *str);
 
int str_utf8_forward(const char *str, int cursor);
 
int str_utf8_decode(const char **ptr);
 
int str_utf8_encode(char *ptr, int chr);
 
int str_utf8_check(const char *str);
 
void str_utf8_copy_num(char *dst, const char *src, int dst_size, int num);
 
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);
 
const char *str_next_token(const char *str, const char *delim, char *buffer, int buffer_size);
 
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_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);
 
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);
 
void crashdump_init_if_available(const char *log_file_path);
 
std::chrono::nanoseconds time_get_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
 
#endif