libfilezilla
Classes | Typedefs | Enumerations | Functions
fz Namespace Reference

The namespace used by libfilezilla. More...

Classes

class  async_task
 Handle for asynchronous tasks. More...
 
class  bucket
 A rate-limited token bucket. More...
 
class  bucket_base
 Base class for buckets. More...
 
class  buffer
 The buffer class is a simple buffer where data can be appended at the end and consumed at the front. Think of it as a deque with contiguous storage. More...
 
class  condition
 Waitable condition variable. More...
 
class  datetime
 Represents a point of time in wallclock, tracking the timestamps accuracy/precision. More...
 
class  duration
 The duration class represents a time interval in milliseconds. More...
 
class  event_base
 Common base class for all events. More...
 
class  event_handler
 Simple handler for asynchronous event processing. More...
 
class  event_loop
 A threaded event loop that supports sending events and timers. More...
 
class  file
 Lean class for file access. More...
 
class  hash_accumulator
 Accumulator for hashing large amounts of data. More...
 
struct  less_insensitive_ascii
 Comparator to be used for std::map for case-insentitive keys. More...
 
class  listen_socket
 Simple Listen socket. More...
 
class  local_filesys
 This class can be used to enumerate the contents of local directories and to query the metadata of files. More...
 
class  logger_interface
 Abstract interface for logging strings. More...
 
class  monotonic_clock
 A monotonic clock (aka steady clock) is independent from walltime. More...
 
class  mutex
 Lean replacement for std::(recursive_)mutex. More...
 
class  private_key
 Represents a X25519 private key with associated salt. More...
 
class  private_signing_key
 Represents a private key to sign message with using Ed25519. More...
 
class  process
 The process class manages an asynchronous process with redirected IO. More...
 
class  public_key
 Represents a X25519 public key with associated salt. More...
 
class  public_verification_key
 Represents a public key to verify messages signed using Ed25519. More...
 
class  query_string
 Class for parsing a URI's query string. More...
 
class  rate_limit_manager
 Context for rate_limiters. More...
 
class  rate_limited_layer
 A rate-limited socket layer. More...
 
class  rate_limiter
 A limiter for the attached buckets. More...
 
class  recursive_remove
 Recursively deletes directories. More...
 
class  result
 Small class to return filesystem errors. More...
 
class  scoped_lock
 A simple scoped lock. More...
 
class  shared_optional
 shared_optional is like std::shared_ptr but with relational operators acting like C++17's std::optional More...
 
class  simple_event
 This is the recommended event class. More...
 
class  socket
 IPv6 capable, non-blocking socket class. More...
 
class  socket_base
 Common base clase for fz::socket and fz::listen_socket. More...
 
class  socket_descriptor
 Lightweight holder for socket descriptors. More...
 
class  socket_event_source
 All classes sending socket events should derive from this. More...
 
class  socket_interface
 Interface for sockets. More...
 
class  socket_layer
 A base class for socket layers. More...
 
class  sparse_optional
 Similar to C++17's std::optional, but stores the data in dynamic memory. More...
 
class  symmetric_key
 Symmetric encryption key with associated salt. More...
 
class  thread
 Spawns and represents a new thread of execution. More...
 
class  thread_pool
 A dumb thread-pool for asynchronous tasks. More...
 
class  tls_layer
 A Transport Layer Security (TLS) layer. More...
 
class  tls_session_info
 Information about a TLS session. More...
 
class  tls_system_trust_store
 Opaque class to load the system trust store asynchronously. More...
 
class  uri
 The uri class is used to decompose URIs into their individual components. More...
 
class  x509_certificate
 Represents all relevant information of a X.509 certificate as used by TLS. More...
 

Typedefs

typedef unsigned long long timer_id
 
typedef simple_event< timer_event_type, timer_id > timer_event
 All timer events have this type. More...
 
template<typename T >
using shared_value = shared_optional< T, true >
 like shared_optional but can never be empty More...
 
typedef simple_event< socket_event_type, socket_event_source *, socket_event_flag, int > socket_event
 
typedef simple_event< hostaddress_event_type, socket_event_source *, std::string > hostaddress_event
 
typedef std::wstring native_string
 A string in the system's native character type and encoding.
Note: This typedef changes depending on platform! More...
 
typedef std::wstring_view native_string_view
 
typedef simple_event< certificate_verification_event_type, tls_layer *, tls_session_infocertificate_verification_event
 This event gets sent during the handshake with details about the session and the used certificate. More...
 

Enumerations

enum  base64_type { standard, url }
 Alphabet variations for base64. More...
 
enum  base32_type { standard, base32hex, locale_safe }
 Alphabet variations for base32. More...
 
enum  hash_algorithm { md5, sha1, sha256, sha512 }
 List of supported hashing algorithms.
 
enum  address_type { unknown, ipv4, ipv6 }
 
enum  { signature_size = 64 }
 
enum  socket_event_flag { connection_next, connection, read, write }
 The type of a socket event. More...
 
enum  listen_socket_state { none, listening }
 
enum  socket_state {
  none, connecting, connected, shutting_down,
  shut_down, closed, failed
}
 State transitions are monotonically increasing. More...
 

Functions

template<typename Obj , typename F , typename Tuple , typename Seq = typename std::make_index_sequence<std::tuple_size<typename std::remove_reference<Tuple>::type>::value>>
auto apply (Obj &&obj, F &&f, Tuple &&args) -> decltype(apply_(std::forward< Obj >(obj), std::forward< F >(f), std::forward< Tuple >(args), Seq()))
 Apply tuple to pointer to member. More...
 
template<typename Char >
int hex_char_to_int (Char c)
 Converts a hex digit to decimal int. More...
 
template<typename OutString = std::vector<uint8_t>>
OutString hex_decode (std::string_view const &in)
 
template<typename OutString = std::vector<uint8_t>>
OutString hex_decode (std::wstring_view const &in)
 
template<typename Char = char, bool Lowercase = true>
Char int_to_hex_char (int d)
 Converts an integer to the corresponding lowercase hex digit. More...
 
template<typename String , typename InString , bool Lowercase = true>
String hex_encode (InString const &data)
 
std::string base64_encode (std::string_view const &in, base64_type type=base64_type::standard, bool pad=true)
 Encodes raw input string to base64.
 
std::string base64_encode (std::vector< uint8_t > const &in, base64_type type=base64_type::standard, bool pad=true)
 
std::vector< uint8_t > base64_decode (std::string_view const &in)
 Decodes base64, ignores whitespace. Returns empty string on invalid input. More...
 
std::vector< uint8_t > base64_decode (std::wstring_view const &in)
 
std::string base64_decode_s (std::string_view const &in)
 
std::string base64_decode_s (std::wstring_view const &in)
 
std::string base32_encode (std::string_view const &in, base32_type type=base32_type::standard, bool pad=true)
 Encodes raw input string to base32.
 
std::string base32_encode (std::vector< uint8_t > const &in, base32_type type=base32_type::standard, bool pad=true)
 
std::vector< uint8_t > base32_decode (std::string_view const &in, base32_type type=base32_type::standard)
 Decodes base32, ignores whitespace. Returns empty string on invalid input. More...
 
std::vector< uint8_t > base32_decode (std::wstring_view const &in, base32_type type=base32_type::standard)
 
std::string base32_decode_s (std::string_view const &in, base32_type type=base32_type::standard)
 
std::string base32_decode_s (std::wstring_view const &in, base32_type type=base32_type::standard)
 
std::string percent_encode (std::string_view const &s, bool keep_slashes=false)
 Percent-enodes string. More...
 
std::string percent_encode (std::wstring_view const &s, bool keep_slashes=false)
 
std::wstring percent_encode_w (std::wstring_view const &s, bool keep_slashes=false)
 Percent-encodes wide-character. Non-ASCII characters are converted to UTF-8 befor they are encoded. More...
 
std::vector< uint8_t > percent_decode (std::string_view const &s, bool allow_embedded_null=false)
 Percent-decodes string. More...
 
std::vector< uint8_t > percent_decode (std::wstring_view const &s, bool allow_embedded_null=false)
 
std::string percent_decode_s (std::string_view const &s, bool allow_embedded_null=false)
 
std::string percent_decode_s (std::wstring_view const &s, bool allow_embedded_null=false)
 
std::vector< uint8_t > encrypt (std::vector< uint8_t > const &plain, public_key const &pub, bool authenticated=true)
 Encrypt the plaintext to the given public key. More...
 
std::vector< uint8_t > encrypt (std::string_view const &plain, public_key const &pub, bool authenticated=true)
 
std::vector< uint8_t > encrypt (uint8_t const *plain, size_t size, public_key const &pub, bool authenticated=true)
 
std::vector< uint8_t > encrypt (std::vector< uint8_t > const &plain, public_key const &pub, std::vector< uint8_t > const &authenticated_data)
 
std::vector< uint8_t > encrypt (std::string_view const &plain, public_key const &pub, std::string_view const &authenticated_data)
 
std::vector< uint8_t > encrypt (uint8_t const *plain, size_t size, public_key const &pub, uint8_t const *authenticated_data, size_t authenticated_data_size)
 
std::vector< uint8_t > decrypt (std::vector< uint8_t > const &chiper, private_key const &priv, bool authenticated=true)
 Decrypt the ciphertext using the given private key. More...
 
std::vector< uint8_t > decrypt (std::string_view const &chiper, private_key const &priv, bool authenticated=true)
 
std::vector< uint8_t > decrypt (uint8_t const *cipher, size_t size, private_key const &priv, bool authenticated=true)
 
std::vector< uint8_t > decrypt (std::vector< uint8_t > const &cipher, private_key const &priv, std::vector< uint8_t > const &authenticated_data)
 
std::vector< uint8_t > decrypt (std::string_view const &cipher, private_key const &priv, std::string_view const &authenticated_data)
 
std::vector< uint8_t > decrypt (uint8_t const *cipher, size_t size, private_key const &priv, uint8_t const *authenticated_data, size_t authenticated_data_size)
 
std::vector< uint8_t > encrypt (std::vector< uint8_t > const &plain, symmetric_key const &key)
 Encrypt the plaintext using the given symmetric key. More...
 
std::vector< uint8_t > encrypt (std::string_view const &plain, symmetric_key const &key)
 
std::vector< uint8_t > encrypt (uint8_t const *plain, size_t size, symmetric_key const &key)
 
std::vector< uint8_t > encrypt (std::vector< uint8_t > const &plain, symmetric_key const &key, std::vector< uint8_t > const &authenticated_data)
 
std::vector< uint8_t > encrypt (std::string_view const &plain, symmetric_key const &key, std::string_view const &authenticated_data)
 
std::vector< uint8_t > encrypt (uint8_t const *plain, size_t size, symmetric_key const &key, uint8_t const *authenticated_data, size_t authenticated_data_size)
 
std::vector< uint8_t > decrypt (std::vector< uint8_t > const &chiper, symmetric_key const &key)
 Decrypt the ciphertext using the given symmetric key. More...
 
std::vector< uint8_t > decrypt (std::string_view const &chiper, symmetric_key const &key)
 
std::vector< uint8_t > decrypt (uint8_t const *cipher, size_t size, symmetric_key const &key)
 
std::vector< uint8_t > decrypt (std::vector< uint8_t > const &cipher, symmetric_key const &key, std::vector< uint8_t > const &authenticated_data)
 
std::vector< uint8_t > decrypt (std::string_view const &cipher, symmetric_key const &key, std::string_view const &authenticated_data)
 
std::vector< uint8_t > decrypt (uint8_t const *cipher, size_t size, symmetric_key const &key, uint8_t const *authenticated_data, size_t authenticated_data_size)
 
template<typename T >
bool same_type (event_base const &ev)
 
template<typename T , typename F >
bool dispatch (event_base const &ev, F &&f)
 Dispatch for simple_event<> based events to simple functors. More...
 
template<typename T , typename H , typename F >
bool dispatch (event_base const &ev, H *h, F &&f)
 Dispatch for simple_event<> based events to pointer to member. More...
 
template<typename T , typename ... Ts, typename H , typename F , typename ... Fs>
bool dispatch (event_base const &ev, H *h, F &&f, Fs &&... fs)
 Compound dispatch for simple_event<> based events. More...
 
bool remove_file (native_string const &name)
 remove the specified file. More...
 
file::creation_flags operator| (file::creation_flags lhs, file::creation_flags rhs)
 
template<typename... Args>
std::string sprintf (std::string_view const &fmt, Args &&... args)
 A simple type-safe sprintf replacement. More...
 
template<typename... Args>
std::wstring sprintf (std::wstring_view const &fmt, Args &&... args)
 
std::vector< uint8_t > md5 (std::string_view const &data)
 Standard MD5. More...
 
std::vector< uint8_t > md5 (std::vector< uint8_t > const &data)
 
std::vector< uint8_t > sha256 (std::string_view const &data)
 Standard SHA256.
 
std::vector< uint8_t > sha256 (std::vector< uint8_t > const &data)
 
std::vector< uint8_t > hmac_sha256 (std::string_view const &key, std::string_view const &data)
 Standard HMAC using SHA256.
 
std::vector< uint8_t > hmac_sha256 (std::vector< uint8_t > const &key, std::vector< uint8_t > const &data)
 
std::vector< uint8_t > hmac_sha256 (std::vector< uint8_t > const &key, std::string_view const &data)
 
std::vector< uint8_t > hmac_sha256 (std::string_view const &key, std::vector< uint8_t > const &data)
 
std::string get_ipv6_long_form (std::string_view const &short_address)
 Given a shortened IPv6 address, returns the full, unshortened address. More...
 
std::wstring get_ipv6_long_form (std::wstring_view const &short_address)
 
bool is_routable_address (std::string_view const &address)
 Tests whether the passed IP address is routable on the public Internet. More...
 
bool is_routable_address (std::wstring_view const &address)
 
address_type get_address_type (std::string_view const &address)
 Gets the type of the passed IP address.
 
address_type get_address_type (std::wstring_view const &address)
 
result mkdir (native_string const &absolute_path, bool recurse, bool current_user_only=false)
 Creates directory if it doesn't yet exist. More...
 
bool spawn_detached_process (std::vector< native_string > const &cmd_with_args)
 Starts a detached process. More...
 
std::vector< uint8_t > sign (std::vector< uint8_t > const &message, private_signing_key const &priv, bool include_message=true)
 Returns the message with the signature appended, created using the passed private key.
 
std::vector< uint8_t > sign (std::string_view const &message, private_signing_key const &priv, bool include_message=true)
 
std::vector< uint8_t > sign (uint8_t const *message, size_t const size, private_signing_key const &priv, bool include_message=true)
 
bool verify (std::vector< uint8_t > const &message, public_verification_key const &pub)
 Verify a message with attached signature. Returns true iff it has been signed by the private key corresponding to the passed public key.
 
bool verify (std::string_view const &message, public_verification_key const &pub)
 
bool verify (uint8_t const *message, size_t const size, public_verification_key const &pub)
 
bool verify (std::vector< uint8_t > const &message, std::vector< uint8_t > const &signature, public_verification_key const &pub)
 Verify a message with detached signature. Returns true iff it has been signed by the private key corresponding to the passed public key.
 
bool verify (std::string_view const &message, std::string_view const &signature, public_verification_key const &pub)
 
bool verify (uint8_t const *message, size_t const message_size, uint8_t const *signature, size_t const sig_size, public_verification_key const &pub)
 
void remove_socket_events (event_handler *handler, socket_event_source const *const source)
 Remove all pending socket events from source sent to handler. More...
 
void change_socket_event_handler (event_handler *old_handler, event_handler *new_handler, socket_event_source const *const source)
 Changes all pending socket events from source. More...
 
std::string socket_error_string (int error)
 Gets a symbolic name for socket errors. More...
 
native_string socket_error_description (int error)
 Gets a human-readable, translated description of the error.
 
native_string to_native (std::string_view const &in)
 Converts std::string to native_string. More...
 
native_string to_native (std::wstring_view const &in)
 Convert std::wstring to native_string. More...
 
template<typename T , typename std::enable_if_t< std::is_same_v< native_string, typename std::decay_t< T >>, int > = 0>
native_string to_native (T const &in)
 Avoid converting native_string to native_string_view and back to string_view.
 
int stricmp (std::string_view const &a, std::string_view const &b)
 Locale-sensitive stricmp. More...
 
int stricmp (std::wstring_view const &a, std::wstring_view const &b)
 
template<typename Char >
Char tolower_ascii (Char c)
 Converts ASCII uppercase characters to lowercase as if C-locale is used. More...
 
template<>
std::wstring::value_type tolower_ascii (std::wstring::value_type c)
 
template<typename Char >
Char toupper_ascii (Char c)
 Converts ASCII lowercase characters to uppercase as if C-locale is used.
 
template<>
std::wstring::value_type toupper_ascii (std::wstring::value_type c)
 
std::string str_tolower_ascii (std::string_view const &s)
 tr_tolower_ascii does for strings what tolower_ascii does for individual characters
 
std::wstring str_tolower_ascii (std::wstring_view const &s)
 
std::string str_toupper_ascii (std::string_view const &s)
 
std::wstring str_toupper_ascii (std::wstring_view const &s)
 
bool equal_insensitive_ascii (std::string_view a, std::string_view b)
 Locale-insensitive stricmp. More...
 
bool equal_insensitive_ascii (std::wstring_view a, std::wstring_view b)
 
std::wstring to_wstring (std::string_view const &in)
 Converts from std::string in system encoding into std::wstring. More...
 
std::wstring to_wstring (std::wstring const &in)
 Returns identity, that way to_wstring can be called with native_string.
 
template<typename Arg >
std::enable_if< std::is_arithmetic< std::decay_t< Arg > >::value, std::wstring >::type to_wstring (Arg &&arg)
 Converts from arithmetic type to std::wstring.
 
std::wstring to_wstring_from_utf8 (std::string const &in)
 Converts from std::string in UTF-8 into std::wstring. More...
 
std::wstring to_wstring_from_utf8 (char const *s, size_t len)
 
std::string to_string (std::wstring_view const &in)
 Converts from std::wstring into std::string in system encoding. More...
 
std::string to_string (std::string const &in)
 Returns identity, that way to_string can be called with native_string.
 
template<typename Arg >
std::enable_if< std::is_arithmetic< std::decay_t< Arg > >::value, std::string >::type to_string (Arg &&arg)
 Converts from arithmetic type to std::string.
 
template<typename Char >
size_t strlen (Char const *str)
 Returns length of 0-terminated character sequence. Works with both narrow and wide-characters.
 
std::string to_utf8 (std::string_view const &in)
 Converts from std::string in native encoding into std::string in UTF-8. More...
 
std::string to_utf8 (std::wstring_view const &in)
 Converts from std::wstring in native encoding into std::string in UTF-8. More...
 
template<typename String , typename Arg >
auto toString (Arg &&arg) -> typename std::enable_if< std::is_same< String, std::string >::value, decltype(to_string(std::forward< Arg >(arg)))>::type
 Calls either fz::to_string or fz::to_wstring depending on the passed template argument.
 
template<typename Char >
Char const * choose_string (char const *c, wchar_t const *w)
 Returns the function argument of the type matching the template argument. More...
 
template<>
char const * choose_string (char const *c, wchar_t const *)
 Returns the function argument of the type matching the template argument. More...
 
template<>
wchar_t const * choose_string (char const *, wchar_t const *w)
 Returns the function argument of the type matching the template argument. More...
 
std::string replaced_substrings (std::string const &in, std::string const &find, std::string const &replacement)
 Returns in with all occurrences of find in the input string replaced with replacement.
 
std::wstring replaced_substrings (std::wstring const &in, std::wstring const &find, std::wstring const &replacement)
 
bool replace_substrings (std::string &in, std::string const &find, std::string const &replacement)
 Modifies in, replacing all occurrences of find with replacement.
 
bool replace_substrings (std::wstring &in, std::wstring const &find, std::wstring const &replacement)
 
std::vector< std::string > strtok (std::string_view const &tokens, std::string_view const &delims, bool const ignore_empty=true)
 Tokenizes string. More...
 
std::vector< std::wstring > strtok (std::wstring_view const &tokens, std::wstring_view const &delims, bool const ignore_empty=true)
 
auto strtok (std::string_view const &tokens, char const delim, bool const ignore_empty=true)
 
auto strtok (std::wstring_view const &tokens, wchar_t const delim, bool const ignore_empty=true)
 
std::vector< std::string_view > strtok_view (std::string_view const &tokens, std::string_view const &delims, bool const ignore_empty=true)
 Tokenizes string. More...
 
std::vector< std::wstring_view > strtok_view (std::wstring_view const &tokens, std::wstring_view const &delims, bool const ignore_empty=true)
 
auto strtok_view (std::string_view const &tokens, char const delim, bool const ignore_empty=true)
 
auto strtok_view (std::wstring_view const &tokens, wchar_t const delim, bool const ignore_empty=true)
 
template<typename T >
to_integral (std::string_view const &s, T const errorval=T())
 Converts string to integral type T. If string is not convertible, errorval is returned.
 
template<typename T >
to_integral (std::wstring_view const &s, T const errorval=T())
 
template<typename T , typename StringType >
to_integral (std::basic_string_view< StringType > const &s, T const errorval=T())
 
template<typename String >
bool str_is_ascii (String const &s)
 Returns true iff the string only has characters in the 7-bit ASCII range.
 
std::string trimmed (std::string_view s, std::string_view const &chars=" \\, bool fromLeft=true, bool fromRight=true)
 Return passed string with all leading and trailing whitespace removed.
 
std::wstring trimmed (std::wstring_view s, std::wstring_view const &chars=L" \\, bool fromLeft=true, bool fromRight=true)
 
std::string ltrimmed (std::string_view s, std::string_view const &chars=" \\)
 
std::wstring ltrimmed (std::wstring_view s, std::wstring_view const &chars=L" \\)
 
std::string rtrimmed (std::string_view s, std::string_view const &chars=" \\)
 
std::wstring rtrimmed (std::wstring_view s, std::wstring_view const &chars=L" \\)
 
template<typename String , typename std::enable_if_t< std::is_same_v< typename String::value_type, char >, int > = 0>
void trim (String &s, std::string_view const &chars=" \\, bool fromLeft=true, bool fromRight=true)
 Remove all leading and trailing whitespace from string.
 
template<typename String , typename std::enable_if_t< std::is_same_v< typename String::value_type, wchar_t >, int > = 0>
void trim (String &s, std::wstring_view const &chars=L" \\, bool fromLeft=true, bool fromRight=true)
 
template<typename String , typename std::enable_if_t< std::is_same_v< typename String::value_type, char >, int > = 0>
void ltrim (String &s, std::string_view const &chars=" \\)
 
template<typename String , typename std::enable_if_t< std::is_same_v< typename String::value_type, wchar_t >, int > = 0>
void ltrim (String &s, std::wstring_view const &chars=L" \\)
 
template<typename String , typename std::enable_if_t< std::is_same_v< typename String::value_type, char >, int > = 0>
void rtrim (String &s, std::string_view const &chars=" \\)
 
template<typename String , typename std::enable_if_t< std::is_same_v< typename String::value_type, wchar_t >, int > = 0>
void rtrim (String &s, std::wstring_view const &chars=L" \\)
 
template<bool insensitive_ascii = false, typename String >
bool starts_with (String const &s, String const &beginning)
 Tests whether the first string starts with the second string. More...
 
template<bool insensitive_ascii = false, typename String >
bool ends_with (String const &s, String const &ending)
 Tests whether the first string ends with the second string. More...
 
duration operator- (duration const &a, duration const &b)
 
duration operator+ (duration const &a, duration const &b)
 
duration operator- (datetime const &a, datetime const &b)
 Gets the difference between two timestamps as duration. More...
 
duration operator- (monotonic_clock const &a, monotonic_clock const &b)
 
void set_translators (std::wstring(*s)(char const *const t), std::wstring(*pf)(char const *const singular, char const *const plural, int64_t n))
 Sets translators for strings. More...
 
std::wstring translate (char const *const source)
 Translates the input string with the configured translator. More...
 
std::wstring translate (char const *const singular, char const *const plural, int64_t n)
 
void sleep (duration const &d)
 Sleep current thread for the specified duration. More...
 
void yield ()
 Relinquish control for a brief amount of time. More...
 
int64_t random_number (int64_t min, int64_t max)
 Get a secure random integer uniformly distributed in the closed interval [min, max].
 
std::vector< uint8_t > random_bytes (size_t size)
 Get random uniformly distributed bytes.
 
uint64_t bitscan (uint64_t v)
 Returns index of the least-significant set bit. More...
 
uint64_t bitscan_reverse (uint64_t v)
 Returns index of the most-significant set bit. More...
 
std::string get_version_string ()
 Get version string of libfilezilla.
 
std::tuple< int, int, int, int, std::string > get_version ()
 Get version of libfilezilla broken down into components major, minor, micro, nano and suffix.
 

Detailed Description

The namespace used by libfilezilla.

All declarations in any libfilezilla header are in this namespace.

Typedef Documentation

◆ certificate_verification_event

typedef simple_event<certificate_verification_event_type, tls_layer*, tls_session_info> certificate_verification_event

This event gets sent during the handshake with details about the session and the used certificate.

After receiving this event, tls_layer::set_verification_result needs to be called eventually.

◆ hostaddress_event

typedef simple_event<hostaddress_event_type, socket_event_source*, std::string> hostaddress_event

Whenever a hostname has been resolved to an IP address, this event is sent with the resolved IP address literal.

◆ native_string

typedef std::string native_string

A string in the system's native character type and encoding.
Note: This typedef changes depending on platform!

On Windows, the system's native encoding is UTF-16, so native_string is typedef'ed to std::wstring.

On all other platform, native_string is a typedef for std::string.

Always using native_string has the benefit that no conversion needs to be performed which is especially useful if dealing with filenames.

◆ shared_value

using shared_value = shared_optional<T, true>

like shared_optional but can never be empty

All operations that would result in an empty shared_optional instead result in a default-constructed value.

As such, operator* and operator-> are always well-defined.

◆ socket_event

typedef simple_event<socket_event_type, socket_event_source*, socket_event_flag, int> socket_event

All socket events are sent through this.

See also
fz::socket_event_flag

If the error value is non-zero for the connection, read and write events, the socket has failed and needs to be closed. Doing anything else with failed sockets is undefined behavior. Failure events can be received at any time.

Read and write events are edge-triggered:

It is a grave violation to call the read/write/shutdown functions again after they returned EAGAIN without first waiting for the event.

◆ timer_event

typedef simple_event<timer_event_type, timer_id> timer_event

All timer events have this type.

All timer events have one arguments of type timer_id which is the id of the timer that triggered.

Enumeration Type Documentation

◆ base32_type

enum base32_type
strong

Alphabet variations for base32.

  • standard: A-Z2-7 as per RFC4648
  • base32hex: Tricontakaidecimal, natural extension of hex with letters G through V
  • locale_safe: Does not contain the letter i

◆ base64_type

enum base64_type
strong

Alphabet variations for base64.

  • standard: Alphabet with / and + as chars 62 and 63
  • url: - and _

◆ listen_socket_state

enum listen_socket_state
strong
Enumerator
none 

How the socket is initially.

listening 

Only in listening state you can get a connection event.

◆ socket_event_flag

enum socket_event_flag
strong

The type of a socket event.

Enumerator
connection_next 

Sent if connection attempt has failed, but there are still additional addresses to try. Errors can be ignored for this type.

connection 

If no error is set, the connection has been established. If an error is set, the connection could not be established.

read 

If no error is set, data has become available. If an error is set, the connection has failed.

write 

If no error is set, data can be written. If an error is set, the connection has failed.

◆ socket_state

enum socket_state
strong

State transitions are monotonically increasing.

Enumerator
none 

How the socket is initially.

connecting 

Only in connecting state you can get a connection event. After sending the event, socket is in connected or failed state depending whether error value is set in the event.

connected 

Socket is in its normal working state. You can get send and receive events.

shutting_down 

Shutting down of the write side. Transitions to shutdown with a single write event.

shut_down 

Write side has finished shutting down. Receive still working normally.

closed 

Socket has been closed. Further events disabled.

failed 

Socket has failed. Further events disabled.

Function Documentation

◆ apply()

auto fz::apply ( Obj &&  obj,
F &&  f,
Tuple &&  args 
) -> decltype(apply_(std::forward<Obj>(obj), std::forward<F>(f), std::forward<Tuple>(args), Seq()))

Apply tuple to pointer to member.

Example:

struct object {
int f(int value, std::string const& str) const { return value + str.size(); }
};
object o;
auto t = std::make_tuple(5, std::string("Hello!"));
int v = fz::apply(&o, &object::f, t);
// v is now 11

◆ base32_decode()

std::vector<uint8_t> fz::base32_decode ( std::string_view const &  in,
base32_type  type = base32_type::standard 
)

Decodes base32, ignores whitespace. Returns empty string on invalid input.

Padding is optional.

◆ base64_decode()

std::vector<uint8_t> fz::base64_decode ( std::string_view const &  in)

Decodes base64, ignores whitespace. Returns empty string on invalid input.

Padding is optional, alphabet is auto-detected.

◆ bitscan()

uint64_t fz::bitscan ( uint64_t  v)

Returns index of the least-significant set bit.

For example bitscan(12) returns 2

Undefined if called with 0

◆ bitscan_reverse()

uint64_t fz::bitscan_reverse ( uint64_t  v)

Returns index of the most-significant set bit.

For example bitscan_reverse(12) returns 3

Undefined if called with 0

◆ change_socket_event_handler()

void fz::change_socket_event_handler ( event_handler old_handler,
event_handler new_handler,
socket_event_source const *const  source 
)

Changes all pending socket events from source.

If newHandler is null, remove_socket_events is called.

This function is called by socket::set_event_handler().

Example use-cases: Handoff after proxy handshakes, or handoff to TLS classes in case of STARTTLS mechanism

◆ choose_string() [1/3]

Char const* fz::choose_string ( char const *  c,
wchar_t const *  w 
)
inline

Returns the function argument of the type matching the template argument.

See also
fzS

◆ choose_string() [2/3]

char const* fz::choose_string ( char const *  c,
wchar_t const *  w 
)
inline

Returns the function argument of the type matching the template argument.

See also
fzS

◆ choose_string() [3/3]

wchar_t const* fz::choose_string ( char const *  c,
wchar_t const *  w 
)
inline

Returns the function argument of the type matching the template argument.

See also
fzS

◆ decrypt() [1/2]

std::vector<uint8_t> fz::decrypt ( std::vector< uint8_t > const &  chiper,
private_key const &  priv,
bool  authenticated = true 
)

Decrypt the ciphertext using the given private key.

Parameters
privThe private key matching the public key that was originally used to encrypt the data
authenticatedif true, authenticated encryption is used.
Returns
plaintext on success, empty container on failure
Decryption algorithm:

Let M_priv be the key portion and S_m be the salt portion of the priv parameter and C the ciphertext.

  • First C is split into E_pub, S_e, C' and T such that
    C: = E_pub || S_e || C' || T
  • M_pub is calculated from M_priv
  • Using ECDH on Curve25519 (X25519), the shared secret R is recovered:
    R := X25519(M_priv, E_pub)
  • From R, a symmetric AES256 key K and a nonce IV are derived:
    • K := SHA256(S_e || 0 || S || E_pub || M_pub || S_m)
    • IV := SHA256(S_e || 2 || S || E_pub || M_pub || S_m) if authenticated,
      IV := SHA256(S_e || 1 || S || E_pub || M_pub || S_m) otherwise
  • The ciphertext is decrypted into the plaintext P using
    P, T' := AES256-GCM(K, IV, C') if authenticated,
    P := AES256-CTR(K, IV, C'), T:='' otherwise
  • If the calculated T' matches T, then P is returned, otherwise decryption has failed and nothing is returned.

◆ decrypt() [2/2]

std::vector<uint8_t> fz::decrypt ( std::vector< uint8_t > const &  chiper,
symmetric_key const &  key 
)

Decrypt the ciphertext using the given symmetric key.

Parameters
privThe symmetric key that was originally used to encrypt the data
Returns
plaintext on success, empty container on failure
Decryption algorithm:

Let M be the key portion and S be the salt portion of the priv parameter and C the ciphertext.

  • First C is split into N, C' and T such that
    C: = N || C' || T
  • From N an AES key K and an IV are derived:
    • K := SHA256(S || 3 || M || N)
    • IV := SHA256(S || 4 || M || N)
  • The ciphertext is decrypted into the plaintext P using
    P, T' := AES256-GCM(K, IV, C')
  • If the calculated T' matches T, then P is returned, otherwise decryption has failed and nothing is returned.

◆ dispatch() [1/3]

bool fz::dispatch ( event_base const &  ev,
F &&  f 
)

Dispatch for simple_event<> based events to simple functors.

Template Parameters
Tthe event type, a simple_event<> instantiation
Parameters
evthe received event
ffunctor that should be called if the event matches the passed type.

If the passed event is of the type passed as template argument, the passed function is called with the contents of the event unpacked as arguments.

Returns
true iff event matches passed type.
See also
event_handler for complete usage example.

◆ dispatch() [2/3]

bool fz::dispatch ( event_base const &  ev,
H *  h,
F &&  f 
)

Dispatch for simple_event<> based events to pointer to member.

Template Parameters
Tthe event type, a simple_event<> instantiation
Parameters
evthe received event.
hobject whose member gets called if the event matches the passed type.
fpointer to member of h that should be called if the event matches the passed type.

If the passed event is of the type passed as template argument, the passed function is called with the contents of the event unpacked as arguments.

Returns
true iff event matches passed type.
See also
event_handler for complete usage example.

◆ dispatch() [3/3]

bool fz::dispatch ( event_base const &  ev,
H *  h,
F &&  f,
Fs &&...  fs 
)

Compound dispatch for simple_event<> based events.

Calls the simple dispatch for each passed type and tries the next one if it didn't match.

Order the passed types in decreasing usage frequency for maximum performance.

Template Parameters
Tthe event type, a simple_event<> instantiation
Tsadditional event types
Parameters
evthe received event.
hobject whose member gets called if the event matches the passed type.
fpointer to member of h that should be called if the event matches the passed type.
fsadditional pairs of objects and pointers to members.
Returns
true iff event matched a passed type.
See also
event_handler for complete usage example.

◆ encrypt() [1/2]

std::vector<uint8_t> fz::encrypt ( std::vector< uint8_t > const &  plain,
public_key const &  pub,
bool  authenticated = true 
)

Encrypt the plaintext to the given public key.

Parameters
authenticatedif true, authenticated encryption is used.
Encryption algorithm:

Let M_pub be the key portion, S_e be the salt portion of the pub parameter and P be the plaintext.

  • First an ephemeral private key E_priv with corresponding public key E_pub and S_e is randomly generated
  • Using ECDH on Curve25519 (X25519), a shared secret R is derived:
    R := X25519(E_priv, M_pub)
  • From R, a symmetric AES256 key K and a nonce IV are derived:
    • K := SHA256(S_e || 0 || S || E_pub || M_pub || S_m)
    • IV := SHA256(S_e || 2 || S || E_pub || M_pub || S_m) if authenticated,
      IV := SHA256(S_e || 1 || S || E_pub || M_pub || S_m) otherwise
  • The plaintext is encrypted into the ciphertext C' and authentication tag T using
    C', T := AES256-GCM(K, IV, P) if authenticated,
    C' := AES256-CTR(K, IV, P) T:='' otherwise
  • The ciphertext C is returned, containing E_pub, S_e and T:
    C := E_pub || S_e || C' || T

◆ encrypt() [2/2]

std::vector<uint8_t> fz::encrypt ( std::vector< uint8_t > const &  plain,
symmetric_key const &  key 
)

Encrypt the plaintext using the given symmetric key.

Encryption algorithm:

Let M be the key portion, S be the salt portion of the key parameter and P be the plaintext.

  • First a ranodm nonce N is created from which an AES key K and an IV are derived:
    • K := SHA256(S || 3 || M || N)
    • IV := SHA256(S || 4 || M || N)
  • The plaintext is encrypted into the ciphertext C' and authentication tag T using
    C', T := AES256-GCM(K, IV, P)
  • The ciphertext C is returned, containing N and T:
    C := N || C' || T

◆ ends_with()

bool fz::ends_with ( String const &  s,
String const &  ending 
)

Tests whether the first string ends with the second string.

Template Parameters
insensitive_asciiIf true, comparison is case-insensitive

◆ equal_insensitive_ascii()

bool fz::equal_insensitive_ascii ( std::string_view  a,
std::string_view  b 
)
inline

Locale-insensitive stricmp.

Equivalent to str_tolower_ascii(a).compare(str_tolower_ascii(b));

◆ get_ipv6_long_form()

std::string fz::get_ipv6_long_form ( std::string_view const &  short_address)

Given a shortened IPv6 address, returns the full, unshortened address.

If passed address is encloded in square brackes, they are stripped.

Returns an empty string if the passed string isn't a valid IPv6 address.

◆ hex_char_to_int()

int fz::hex_char_to_int ( Char  c)

Converts a hex digit to decimal int.

Example: '9' becomes 9, 'b' becomes 11, 'D' becomes 13

Returns -1 if input is not a valid hex digit.

◆ int_to_hex_char()

Char fz::int_to_hex_char ( int  d)

Converts an integer to the corresponding lowercase hex digit.

Example: 9 becomes '9', 11 becomes 'b'

Undefined output if input is less than 0 or larger than 15

◆ is_routable_address()

bool fz::is_routable_address ( std::string_view const &  address)

Tests whether the passed IP address is routable on the public Internet.

Unroutable addresss are:

  • Invalid addresses
  • ::/128 (the unspecified address)
  • ::1/128 (localhost)
  • fe80::/10 (link-local)
  • fc00::/7 (unique local)
  • 127.0.0.0/8 (localhost)
  • 10.0.0.0/8 (private)
  • 172.16.0.0/12 (private)
  • 192.168.0.0/16 (private)
  • 169.254.0.0/16 (link-local)

All other addresses are assumed routable.

◆ md5()

std::vector<uint8_t> fz::md5 ( std::string_view const &  data)

Standard MD5.

Insecure, avoid using this

◆ mkdir()

result fz::mkdir ( native_string const &  absolute_path,
bool  recurse,
bool  current_user_only = false 
)

Creates directory if it doesn't yet exist.

If current_user_only is set, the directory is created with permissions so that only the current user has access, otherwise the default permissions are used.

This function only works with absolute paths.

◆ operator-() [1/2]

duration operator- ( datetime const &  a,
datetime const &  b 
)

Gets the difference between two timestamps as duration.

This function ignores accuracy, it treats both timestamps as if they had millisecond-accuracy.

◆ operator-() [2/2]

duration operator- ( monotonic_clock const &  a,
monotonic_clock const &  b 
)
inline

Gets the difference between two clocks as duration

◆ percent_decode()

std::vector<uint8_t> fz::percent_decode ( std::string_view const &  s,
bool  allow_embedded_null = false 
)

Percent-decodes string.

If the string cannot be decoded, an empty string is returned.

◆ percent_encode()

std::string fz::percent_encode ( std::string_view const &  s,
bool  keep_slashes = false 
)

Percent-enodes string.

The characters A-Z, a-z, 0-9, hyphen, underscore, period, tilde are not percent-encoded, optionally slashes arne't encoded either. Every other character is encoded.

Parameters
keep_slashesIf set, slashes are not encoded.

◆ percent_encode_w()

std::wstring fz::percent_encode_w ( std::wstring_view const &  s,
bool  keep_slashes = false 
)

Percent-encodes wide-character. Non-ASCII characters are converted to UTF-8 befor they are encoded.

See also
fz::percent_encode

◆ remove_file()

bool fz::remove_file ( native_string const &  name)

remove the specified file.

Returns
true iff the file has been removed or did not exist to begin with.

◆ remove_socket_events()

void fz::remove_socket_events ( event_handler handler,
socket_event_source const *const  source 
)

Remove all pending socket events from source sent to handler.

Useful e.g. if you want to destroy the handler but keep the source. This function is called, through change_socket_event_handler, by socket::set_event_handler(0)

◆ same_type()

bool fz::same_type ( event_base const &  ev)

Used as lightweight RTTI alternative during dispatch

Returns
true iff T& t = ...; t.derived_type() == ev.derived_type()

◆ set_translators()

void fz::set_translators ( std::wstring(*)(char const *const t)  s,
std::wstring(*)(char const *const singular, char const *const plural, int64_t n)  pf 
)

Sets translators for strings.

You could pass functions that in turn call gettext/ngettext

◆ sleep()

void fz::sleep ( duration const &  d)

Sleep current thread for the specified duration.

Alternative to std::this_thread::sleep_for which unfortunately isn't implemented on MinGW.

Note
May wake up early, e.g. due to a signal. You can use monotonic_clock to check elapsed time and sleep again if needed.

◆ socket_error_string()

std::string fz::socket_error_string ( int  error)

Gets a symbolic name for socket errors.

For example, error_string(EAGAIN) == "EAGAIN"

Returns
name if the error code is known
number as string if the error code is not known

◆ spawn_detached_process()

bool fz::spawn_detached_process ( std::vector< native_string > const &  cmd_with_args)

Starts a detached process.

This function takes care of properly quoting and escaping the the program's path and its arguments.

Parameters
cmd_with_argsThe full path of the program to execute and any additional arguments
Note
May return true even if the process cannot be started.

◆ sprintf()

std::string fz::sprintf ( std::string_view const &  fmt,
Args &&...  args 
)

A simple type-safe sprintf replacement.

Only partially implements the format specifiers for the printf family of C functions:

  • Positional arguments
  • Supported flags: 0, ' ', -, +
  • Field widths are supported as decimal integers not exceeding 10k, longer widths are truncated
  • precision is ignored
  • Supported types: d, i, u, s, x, X, p

For string arguments, mixing char*, wchar_t*, std::string and std::wstring is allowed.

Asserts if unsupported types are passed or if the types don't match the arguments. Fails gracefully with NDEBUG.

Example:

std::string s = fz::printf("%2$s %1$s", "foo", std::wstring("bar");
assert(s == "bar foo"); // This is true

◆ starts_with()

bool fz::starts_with ( String const &  s,
String const &  beginning 
)

Tests whether the first string starts with the second string.

Template Parameters
insensitive_asciiIf true, comparison is case-insensitive

◆ stricmp()

int fz::stricmp ( std::string_view const &  a,
std::string_view const &  b 
)

Locale-sensitive stricmp.

Like std::string::compare but case-insensitive, respecting locale.

Note
does not handle embedded null

◆ strtok()

std::vector<std::string> fz::strtok ( std::string_view const &  tokens,
std::string_view const &  delims,
bool const  ignore_empty = true 
)

Tokenizes string.

Parameters
delimsthe delimiters to look for
ignore_emptyIf true, empty tokens are omitted in the output

◆ strtok_view()

std::vector<std::string_view> fz::strtok_view ( std::string_view const &  tokens,
std::string_view const &  delims,
bool const  ignore_empty = true 
)

Tokenizes string.

Warning
This function returns string_views, mind the lifetime of the string passed in tokens.
Parameters
delimsthe delimiters to look for
ignore_emptyIf true, empty tokens are omitted in the output

◆ to_native() [1/2]

native_string fz::to_native ( std::string_view const &  in)

Converts std::string to native_string.

Returns
the converted string on success. On failure an empty string is returned.
Examples:
list.cpp, and process.cpp.

◆ to_native() [2/2]

native_string fz::to_native ( std::wstring_view const &  in)

Convert std::wstring to native_string.

Returns
the converted string on success. On failure an empty string is returned.

◆ to_string()

std::string fz::to_string ( std::wstring_view const &  in)

Converts from std::wstring into std::string in system encoding.

Returns
the converted string on success. On failure an empty string is returned.
Examples:
list.cpp.

◆ to_utf8() [1/2]

std::string fz::to_utf8 ( std::string_view const &  in)

Converts from std::string in native encoding into std::string in UTF-8.

Returns
the converted string on success. On failure an empty string is returned.
Note
Does not handle embedded nulls

◆ to_utf8() [2/2]

std::string fz::to_utf8 ( std::wstring_view const &  in)

Converts from std::wstring in native encoding into std::string in UTF-8.

Returns
the converted string on success. On failure an empty string is returned.
Note
Does not handle embedded nulls

◆ to_wstring()

std::wstring fz::to_wstring ( std::string_view const &  in)

Converts from std::string in system encoding into std::wstring.

Returns
the converted string on success. On failure an empty string is returned.

◆ to_wstring_from_utf8()

std::wstring fz::to_wstring_from_utf8 ( std::string const &  in)

Converts from std::string in UTF-8 into std::wstring.

Returns
the converted string on success. On failure an empty string is returned.

◆ tolower_ascii()

Char fz::tolower_ascii ( Char  c)

Converts ASCII uppercase characters to lowercase as if C-locale is used.

Under some locales there is a different case-relationship between the letters a-z and A-Z as one expects from ASCII under the C locale. In Turkish for example there are different variations of the letter i, namely dotted and dotless. What we see as 'i' is the lowercase dotted i and 'I' is the uppercase dotless i. Since std::tolower is locale-aware, I would become the dotless lowercase i.

This is not always what we want. FTP commands for example are case-insensitive ASCII strings, LIST and list are the same.

tolower_ascii instead converts all types of 'i's to the ASCII i as well.

Returns
A-Z becomes a-z.
In addition dotless lowercase i and dotted uppercase i also become the standard i.

◆ translate()

std::wstring fz::translate ( char const *const  source)

Translates the input string with the configured translator.

Returns the untranslated string is if no translator has previously been configured

◆ yield()

void fz::yield ( )

Relinquish control for a brief amount of time.

The exact duration is unspecified.