ddnet/src/base/system.h

955 lines
19 KiB
C
Raw Normal View History

2007-11-25 19:42:40 +00:00
/* copyright (c) 2007 magnus auvinen, see licence.txt for more info */
/*
Title: OS Abstraction
*/
#ifndef BASE_SYSTEM_H
#define BASE_SYSTEM_H
#include "detect.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Group: Debug */
/*
Function: dbg_assert
Breaks into the debugger based on a test.
Parameters:
test - Result of the test.
msg - Message that should be printed if the test fails.
Remarks:
Does nothing in release version of the library.
See Also:
<dbg_break>
*/
void dbg_assert(int test, const char *msg);
#define dbg_assert(test,msg) dbg_assert_imp(__FILE__, __LINE__, test, msg)
void dbg_assert_imp(const char *filename, int line, int test, const char *msg);
/*
Function: dbg_break
Breaks into the debugger.
Remarks:
Does nothing in release version of the library.
See Also:
<dbg_assert>
*/
void dbg_break();
/*
Function: dbg_msg
Prints a debug message.
Parameters:
sys - A string that describes what system the message belongs to
fmt - A printf styled format string.
Remarks:
Does nothing in relase version of the library.
See Also:
<dbg_assert>
*/
void dbg_msg(const char *sys, const char *fmt, ...);
/* Group: Memory */
/*
Function: mem_alloc
Allocates memory.
Parameters:
size - Size of the needed block.
alignment - Alignment for the block.
Returns:
Returns a pointer to the newly allocated block. Returns a
null pointer if the memory couldn't be allocated.
Remarks:
- Passing 0 to size will allocated the smallest amount possible
and return a unique pointer.
See Also:
<mem_free>
*/
void *mem_alloc_debug(const char *filename, int line, unsigned size, unsigned alignment);
#define mem_alloc(s,a) mem_alloc_debug(__FILE__, __LINE__, (s), (a))
/*
Function: mem_free
Frees a block allocated through <mem_alloc>.
Remarks:
- In the debug version of the library the function will assert if
a non-valid block is passed, like a null pointer or a block that
isn't allocated.
See Also:
<mem_alloc>
*/
void mem_free(void *block);
/*
Function: mem_copy
Copies a a memory block.
Parameters:
dest - Destination.
source - Source to copy.
size - Size of the block to copy.
Remarks:
- This functions DOES NOT handles cases where source and
destination is overlapping.
See Also:
<mem_move>
*/
void mem_copy(void *dest, const void *source, unsigned size);
/*
Function: mem_move
Copies a a memory block
Parameters:
dest - Destination
source - Source to copy
size - Size of the block to copy
Remarks:
- This functions handles cases where source and destination
is overlapping
See Also:
<mem_copy>
*/
void mem_move(void *dest, const void *source, unsigned size);
/*
Function: mem_zero
Sets a complete memory block to 0
Parameters:
block - Pointer to the block to zero out
size - Size of the block
*/
void mem_zero(void *block, unsigned size);
/*
Function: mem_comp
Compares two blocks of memory
Parameters:
a - First block of data
b - Second block of data
size - Size of the data to compare
Returns:
<0 - Block a is lesser then block b
0 - Block a is equal to block b
>0 - Block a is greater then block b
*/
int mem_comp(const void *a, const void *b, int size);
2008-10-06 16:44:34 +00:00
/*
Function: mem_check
Validates the heap
Will trigger a assert if memory has failed.
*/
2008-10-07 16:17:58 +00:00
int mem_check_imp();
#define mem_check() dbg_assert_imp(__FILE__, __LINE__, mem_check_imp(), "Memory check failed")
2008-10-06 16:44:34 +00:00
/* Group: File IO */
enum {
IOFLAG_READ = 1,
IOFLAG_WRITE = 2,
IOFLAG_RANDOM = 4,
IOSEEK_START = 0,
IOSEEK_CUR = 1,
IOSEEK_END = 2
};
typedef struct IOINTERNAL *IOHANDLE;
/*
Function: io_open
Opens a file.
Parameters:
filename - File to open.
flags - A set of flags. IOFLAG_READ, IOFLAG_WRITE, IOFLAG_RANDOM.
Returns:
Returns a handle to the file on success and 0 on failure.
*/
IOHANDLE io_open(const char *filename, int flags);
/*
Function: io_read
Reads data into a buffer from a file.
Parameters:
io - Handle to the file to read data from.
buffer - Pointer to the buffer that will recive the data.
size - Number of bytes to read from the file.
Returns:
Number of bytes read.
*/
unsigned io_read(IOHANDLE io, void *buffer, unsigned size);
/*
Function: io_skip
Skips data in a file.
Parameters:
io - Handle to the file.
size - Number of bytes to skip.
Returns:
Number of bytes skipped.
*/
unsigned io_skip(IOHANDLE io, unsigned size);
/*
Function: io_write
Writes data from a buffer to file.
Parameters:
io - Handle to the file.
buffer - Pointer to the data that should be written.
size - Number of bytes to write.
Returns:
Number of bytes written.
*/
unsigned io_write(IOHANDLE io, const void *buffer, unsigned size);
/*
Function: io_seek
Seeks to a specified offset in the file.
Parameters:
io - Handle to the file.
offset - Offset from pos to stop.
origin - Position to start searching from.
Returns:
Returns 0 on success.
*/
int io_seek(IOHANDLE io, int offset, int origin);
/*
Function: io_tell
Gets the current position in the file.
Parameters:
io - Handle to the file.
Returns:
Returns the current position. -1L if an error occured.
*/
long int io_tell(IOHANDLE io);
/*
Function: io_length
Gets the total length of the file. Resetting cursor to the beginning
Parameters:
io - Handle to the file.
Returns:
Returns the total size. -1L if an error occured.
*/
long int io_length(IOHANDLE io);
/*
Function: io_close
Closes a file.
Parameters:
io - Handle to the file.
Returns:
Returns 0 on success.
*/
int io_close(IOHANDLE io);
/*
2008-03-10 00:48:45 +00:00
Function: io_flush
Empties all buffers and writes all pending data.
Parameters:
io - Handle to the file.
Returns:
Returns 0 on success.
*/
2008-03-10 00:48:45 +00:00
int io_flush(IOHANDLE io);
/*
Function: io_stdin
Returns an <IOHANDLE> to the standard input.
*/
IOHANDLE io_stdin();
/*
Function: io_stdout
Returns an <IOHANDLE> to the standard output.
*/
IOHANDLE io_stdout();
/*
Function: io_stderr
Returns an <IOHANDLE> to the standard error.
*/
IOHANDLE io_stderr();
/* Group: Threads */
/*
Function: thread_sleep
Suspends the current thread for a given period.
Parameters:
milliseconds - Number of milliseconds to sleep.
*/
void thread_sleep(int milliseconds);
/*
Function: thread_create
Creates a new thread.
Parameters:
threadfunc - Entry point for the new thread.
user - Pointer to pass to the thread.
*/
void *thread_create(void (*threadfunc)(void *), void *user);
/*
Function: thread_wait
Waits for a thread to be done or destroyed.
Parameters:
thread - Thread to wait for.
*/
void thread_wait(void *thread);
/*
Function: thread_destoy
Destroys a thread.
Parameters:
thread - Thread to destroy.
*/
void thread_destroy(void *thread);
/*
Function: thread_yeild
Yeild the current threads execution slice.
*/
void thread_yield();
/* Group: Locks */
2007-10-04 09:49:38 +00:00
typedef void* LOCK;
LOCK lock_create();
void lock_destroy(LOCK lock);
int lock_try(LOCK lock);
void lock_wait(LOCK lock);
void lock_release(LOCK lock);
/* Group: Timer */
2007-10-06 17:01:06 +00:00
#ifdef __GNUC__
/* if compiled with -pedantic-errors it will complain about long
not being a C90 thing.
*/
__extension__ typedef long long int64;
#else
typedef long long int64;
2007-10-06 17:01:06 +00:00
#endif
/*
Function: time_get
Fetches a sample from a high resolution timer.
Returns:
Current value of the timer.
Remarks:
To know how fast the timer is ticking, see <time_freq>.
*/
int64 time_get();
/*
Function: time_freq
Returns the frequency of the high resolution timer.
Returns:
Returns the frequency of the high resolution timer.
*/
int64 time_freq();
/*
Function: time_timestamp
Retrives the current time as a UNIX timestamp
Returns:
The time as a UNIX timestamp
*/
unsigned time_timestamp();
2008-08-05 21:37:33 +00:00
/* Group: Network General */
typedef int NETSOCKET;
enum
{
NETSOCKET_INVALID = -1,
NETTYPE_INVALID = 0,
NETTYPE_IPV4 = 1,
NETTYPE_IPV6 = 2,
NETTYPE_ALL = ~0
};
typedef struct
{
unsigned int type;
unsigned char ip[16];
unsigned short port;
} NETADDR;
2008-08-05 21:37:33 +00:00
/*
Function: net_init
Initiates network functionallity.
Returns:
Returns 0 on success,
Remarks:
You must call this function before using any other network
functions.
*/
int net_init();
/*
Function: net_host_lookup
2008-08-05 21:37:33 +00:00
Does a hostname lookup by name and fills out the passed
NETADDR struct with the recieved details.
Returns:
0 on success.
*/
int net_host_lookup(const char *hostname, NETADDR *addr, int types);
2008-08-05 21:37:33 +00:00
/*
Function: net_addr_comp
Compares two network addresses.
Parameters:
a - Address to compare
b - Address to compare to.
Returns:
<0 - Address a is lesser then address b
0 - Address a is equal to address b
>0 - Address a is greater then address b
*/
int net_addr_comp(const NETADDR *a, const NETADDR *b);
/*
Function: net_addr_str
Turns a network address into a representive string.
Parameters:
addr - Address to turn into a string.
string - Buffer to fill with the string.
max_length - Maximum size of the string.
Remarks:
- The string will always be zero terminated
*/
void net_addr_str(const NETADDR *addr, char *string, int max_length);
2008-08-05 21:37:33 +00:00
2008-09-03 21:02:30 +00:00
/*
Function: net_addr_from_str
Turns string into a network address.
Returns:
0 on success
Parameters:
addr - Address to fill in.
string - String to parse.
*/
int net_addr_from_str(NETADDR *addr, const char *string);
/* Group: Network UDP */
/*
Function: net_udp_create
Creates a UDP socket and binds it to a port.
Parameters:
2008-08-05 21:37:33 +00:00
bindaddr - Address to bind the socket to.
Returns:
2008-08-05 21:37:33 +00:00
On success it returns an handle to the socket. On failure it
returns NETSOCKET_INVALID.
*/
NETSOCKET net_udp_create(NETADDR bindaddr);
/*
Function: net_udp_send
Sends a packet over an UDP socket.
Parameters:
sock - Socket to use.
addr - Where to send the packet.
data - Pointer to the packet data to send.
size - Size of the packet.
Returns:
2008-08-05 21:37:33 +00:00
On success it returns the number of bytes sent. Returns -1
on error.
*/
int net_udp_send(NETSOCKET sock, const NETADDR *addr, const void *data, int size);
/*
Function: net_udp_recv
Recives a packet over an UDP socket.
Parameters:
sock - Socket to use.
addr - Pointer to an NETADDR that will recive the address.
data - Pointer to a buffer that will recive the data.
maxsize - Maximum size to recive.
Returns:
2008-08-05 21:37:33 +00:00
On success it returns the number of bytes recived. Returns -1
on error.
*/
int net_udp_recv(NETSOCKET sock, NETADDR *addr, void *data, int maxsize);
/*
Function: net_udp_close
Closes an UDP socket.
Parameters:
sock - Socket to close.
Returns:
Returns 0 on success. -1 on error.
*/
int net_udp_close(NETSOCKET sock);
/* Group: Network TCP */
/*
Function: net_tcp_create
2008-08-05 21:37:33 +00:00
Creates a TCP socket.
2008-08-05 21:37:33 +00:00
Parameters:
bindaddr - Address to bind the socket to.
2008-08-05 21:37:33 +00:00
Returns:
On success it returns an handle to the socket. On failure it returns NETSOCKET_INVALID.
*/
2008-08-05 21:37:33 +00:00
NETSOCKET net_tcp_create(const NETADDR *a);
/*
Function: net_tcp_listen
2008-08-05 21:37:33 +00:00
Makes the socket start listening for new connections.
Parameters:
sock - Socket to start listen to.
backlog - Size of the queue of incomming connections to keep.
Returns:
Returns 0 on success.
*/
int net_tcp_listen(NETSOCKET sock, int backlog);
/*
Function: net_tcp_accept
2008-08-05 21:37:33 +00:00
Polls a listning socket for a new connection.
Parameters:
sock - Listning socket to poll.
new_sock - Pointer to a socket to fill in with the new socket.
addr - Pointer to an address that will be filled in the remote address (optional, can be NULL).
2008-08-05 21:37:33 +00:00
Returns:
Returns a non-negative integer on success. Negative integer on failure.
*/
2008-08-05 21:37:33 +00:00
int net_tcp_accept(NETSOCKET sock, NETSOCKET *new_sock, NETADDR *addr);
/*
Function: net_tcp_connect
2008-08-05 21:37:33 +00:00
Connects one socket to another.
Parameters:
sock - Socket to connect.
addr - Address to connect to.
2008-08-05 21:37:33 +00:00
Returns:
Returns 0 on success.
*/
2008-08-05 21:37:33 +00:00
int net_tcp_connect(NETSOCKET sock, const NETADDR *addr);
/*
Function: net_tcp_send
2008-08-05 21:37:33 +00:00
Sends data to a TCP stream.
2008-08-05 21:37:33 +00:00
Parameters:
sock - Socket to send data to.
data - Pointer to the data to send.
size - Size of the data to send.
Returns:
Number of bytes sent. Negative value on failure.
*/
int net_tcp_send(NETSOCKET sock, const void *data, int size);
/*
Function: net_tcp_recv
2008-08-05 21:37:33 +00:00
Recvives data from a TCP stream.
Parameters:
sock - Socket to recvive data from.
data - Pointer to a buffer to write the data to
max_size - Maximum of data to write to the buffer.
Returns:
2008-09-23 07:43:41 +00:00
Number of bytes recvived. Negative value on failure. When in
non-blocking mode, it returns 0 when there is no more data to
be fetched.
*/
int net_tcp_recv(NETSOCKET sock, void *data, int maxsize);
/*
Function: net_tcp_close
2008-08-05 21:37:33 +00:00
Closes a TCP socket.
2008-08-05 21:37:33 +00:00
Parameters:
sock - Socket to close.
Returns:
Returns 0 on success. Negative value on failure.
*/
int net_tcp_close(NETSOCKET sock);
/* Group: Strings */
/*
Function: str_append
Appends a string to another.
Parameters:
dst - Pointer to a buffer that contains a string.
src - String to append.
dst_size - Size of the buffer of the dst string.
Remarks:
- The strings are treated as zero-termineted strings.
- Garantees that dst string will contain zero-termination.
*/
void str_append(char *dst, const char *src, int dst_size);
/*
Function: str_copy
Copies a string to another.
Parameters:
dst - Pointer to a buffer that shall recive the string.
src - String to be copied.
dst_size - Size of the buffer dst.
2007-09-25 19:48:52 +00:00
Remarks:
- The strings are treated as zero-termineted strings.
- Garantees that dst string will contain zero-termination.
*/
void str_copy(char *dst, const char *src, int dst_size);
2008-02-10 21:54:52 +00:00
/*
Function: str_length
Returns the length of a zero terminated string.
Parameters:
str - Pointer to the string.
Returns:
Length of string in bytes excluding the zero termination.
*/
int str_length(const char *str);
/*
Function: str_format
Performs printf formating into a buffer.
Parameters:
buffer - Pointer to the buffer to recive the formated string.
buffer_size - Size of the buffer.
format - printf formating string.
... - Parameters for the formating.
Remarks:
- See the C manual for syntax for the printf formating string.
- The strings are treated as zero-termineted strings.
- Garantees that dst string will contain zero-termination.
*/
void str_format(char *buffer, int buffer_size, const char *format, ...);
/*
Function: str_sanitize_strong
Replaces all characters below 32 and above 127 with whitespace.
Parameters:
str - String to sanitize.
Remarks:
- The strings are treated as zero-termineted strings.
*/
2008-02-24 16:03:58 +00:00
void str_sanitize_strong(char *str);
/*
Function: str_sanitize
Replaces all characters below 32 and above 127 with whitespace with
exception to \r, \n and \r.
Parameters:
str - String to sanitize.
Remarks:
- The strings are treated as zero-termineted strings.
*/
2008-02-24 16:03:58 +00:00
void str_sanitize(char *str);
/*
Function: str_comp_nocase
Compares to strings case insensitive.
Parameters:
a - String to compare.
b - String to compare.
Returns:
2008-08-05 21:37:33 +00:00
<0 - String a is lesser then string b
0 - String a is equal to string b
>0 - String a is greater then string b
Remarks:
- Only garanted to work with a-z/A-Z.
- The strings are treated as zero-termineted strings.
*/
int str_comp_nocase(const char *a, const char *b);
/*
Function: str_find_nocase
Finds a string inside another string case insensitive.
Parameters:
haystack - String to search in
needle - String to search for
Returns:
A pointer into haystack where the needle was found.
Returns NULL of needle could not be found.
Remarks:
- Only garanted to work with a-z/A-Z.
- The strings are treated as zero-termineted strings.
*/
const char *str_find_nocase(const char *haystack, const char *needle);
/*
Function: str_hex
Takes a datablock and generates a hexstring of it.
Parameters:
dst - Buffer to fill with hex data
dst_size - size of the buffer
data - Data to turn into hex
data - Size of the data
Remarks:
- The desination buffer will be zero-terminated
*/
void str_hex(char *dst, int dst_size, const void *data, int data_size);
2008-02-24 16:03:58 +00:00
2008-08-05 21:37:33 +00:00
/* Group: Filesystem */
/*
Function: fs_listdir
Lists the files in a directory
Parameters:
dir - Directory to list
cb - Callback function to call for each entry
user - Pointer to give to the callback
Returns:
2008-08-05 21:37:33 +00:00
Always returns 0.
*/
typedef void (*FS_LISTDIR_CALLBACK)(const char *name, int is_dir, void *user);
int fs_listdir(const char *dir, FS_LISTDIR_CALLBACK cb, void *user);
/*
Function: fs_makedir
Creates a directory
Parameters:
path - Directory to create
Returns:
2008-08-05 21:37:33 +00:00
Returns 0 on success. Negative value on failure.
Remarks:
Does not create several directories if needed. "a/b/c" will result
in a failure if b or a does not exist.
*/
int fs_makedir(const char *path);
/*
Function: fs_storage_path
Fetches per user configuration directory.
Returns:
2008-08-05 21:37:33 +00:00
Returns 0 on success. Negative value on failure.
Remarks:
- Returns ~/.appname on UNIX based systems
2008-08-05 21:37:33 +00:00
- Returns ~/Library/Applications Support/appname on Mac OS X
- Returns %APPDATA%/Appname on Windows based systems
*/
int fs_storage_path(const char *appname, char *path, int max);
/*
Function: fs_is_dir
Checks if directory exists
Returns:
Returns 1 on success, 0 on failure.
*/
int fs_is_dir(const char *path);
/*
Function: fs_chdir
Changes current working directory
Returns:
Returns 0 on success, 1 on failure.
*/
int fs_chdir(const char *path);
/*
Group: Undocumented
*/
2008-08-05 21:37:33 +00:00
/*
Function: net_tcp_connect_non_blocking
DOCTODO: serp
*/
int net_tcp_connect_non_blocking(NETSOCKET sock, const NETADDR *a);
/*
Function: net_tcp_set_non_blocking
DOCTODO: serp
*/
int net_tcp_set_non_blocking(NETSOCKET sock);
/*
Function: net_tcp_set_non_blocking
DOCTODO: serp
*/
int net_tcp_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 mem_debug_dump();
void swap_endian(void *data, unsigned elem_size, unsigned num);
2008-03-10 00:48:45 +00:00
typedef void (*DBG_LOGGER)(const char *line);
void dbg_logger(DBG_LOGGER logger);
void dbg_logger_stdout();
void dbg_logger_debugger();
void dbg_logger_file(const char *filename);
typedef struct
{
int allocated;
int active_allocations;
int total_allocations;
} MEMSTATS;
const MEMSTATS *mem_stats();
typedef struct
{
int sent_packets;
int sent_bytes;
int recv_packets;
int recv_bytes;
} NETSTATS;
void net_stats(NETSTATS *stats);
int str_isspace(char c);
/*
Function: gui_messagebox
Display plain OS-dependent message box
Parameters:
title - title of the message box
message - text to display
*/
void gui_messagebox(const char *title, const char *message);
#ifdef __cplusplus
}
#endif
#endif