![]() |
libfilezilla
|
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_info > | certificate_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 > | |
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 > | |
T | to_integral (std::wstring_view const &s, T const errorval=T()) |
template<typename T , typename StringType > | |
T | 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. | |
The namespace used by libfilezilla.
All declarations in any libfilezilla header are in this namespace.
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.
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.
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.
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.
typedef simple_event<socket_event_type, socket_event_source*, socket_event_flag, int> socket_event |
All socket events are sent through this.
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.
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.
|
strong |
Alphabet variations for base32.
|
strong |
Alphabet variations for base64.
|
strong |
|
strong |
The type of a socket event.
|
strong |
State transitions are monotonically increasing.
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:
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.
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.
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
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
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
|
inline |
Returns the function argument of the type matching the template argument.
|
inline |
Returns the function argument of the type matching the template argument.
|
inline |
Returns the function argument of the type matching the template argument.
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.
priv | The private key matching the public key that was originally used to encrypt the data |
authenticated | if true, authenticated encryption is used. |
Let M_priv be the key portion and S_m be the salt portion of the priv parameter and C the ciphertext.
C: = E_pub || S_e || C' || T
R := X25519(M_priv, E_pub)
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)
otherwiseP, T' := AES256-GCM(K, IV, C')
if authenticated,P := AES256-CTR(K, IV, C'), T:=''
otherwisestd::vector<uint8_t> fz::decrypt | ( | std::vector< uint8_t > const & | chiper, |
symmetric_key const & | key | ||
) |
Decrypt the ciphertext using the given symmetric key.
priv | The symmetric key that was originally used to encrypt the data |
Let M be the key portion and S be the salt portion of the priv parameter and C the ciphertext.
C: = N || C' || T
K := SHA256(S || 3 || M || N)
IV := SHA256(S || 4 || M || N)
P, T' := AES256-GCM(K, IV, C')
bool fz::dispatch | ( | event_base const & | ev, |
F && | f | ||
) |
Dispatch for simple_event<> based events to simple functors.
T | the event type, a simple_event<> instantiation |
ev | the received event |
f | functor 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.
bool fz::dispatch | ( | event_base const & | ev, |
H * | h, | ||
F && | f | ||
) |
Dispatch for simple_event<> based events to pointer to member.
T | the event type, a simple_event<> instantiation |
ev | the received event. |
h | object whose member gets called if the event matches the passed type. |
f | pointer 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.
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.
T | the event type, a simple_event<> instantiation |
Ts | additional event types |
ev | the received event. |
h | object whose member gets called if the event matches the passed type. |
f | pointer to member of h that should be called if the event matches the passed type. |
fs | additional pairs of objects and pointers to members. |
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.
authenticated | if true, authenticated encryption is used. |
Let M_pub be the key portion, S_e be the salt portion of the pub parameter and P be the plaintext.
R := X25519(E_priv, M_pub)
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)
otherwiseC', T := AES256-GCM(K, IV, P)
if authenticated,C' := AES256-CTR(K, IV, P)
T:='' otherwiseC := E_pub || S_e || C' || T
std::vector<uint8_t> fz::encrypt | ( | std::vector< uint8_t > const & | plain, |
symmetric_key const & | key | ||
) |
Encrypt the plaintext using the given symmetric key.
Let M be the key portion, S be the salt portion of the key parameter and P be the plaintext.
K := SHA256(S || 3 || M || N)
IV := SHA256(S || 4 || M || N)
C', T := AES256-GCM(K, IV, P)
C := N || C' || T
bool fz::ends_with | ( | String const & | s, |
String const & | ending | ||
) |
Tests whether the first string ends with the second string.
insensitive_ascii | If true, comparison is case-insensitive |
|
inline |
Locale-insensitive stricmp.
Equivalent to str_tolower_ascii(a).compare(str_tolower_ascii(b));
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.
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.
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
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:
All other addresses are assumed routable.
std::vector<uint8_t> fz::md5 | ( | std::string_view const & | data | ) |
Standard MD5.
Insecure, avoid using this
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.
Gets the difference between two timestamps as duration.
This function ignores accuracy, it treats both timestamps as if they had millisecond-accuracy.
|
inline |
Gets the difference between two clocks as duration
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.
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.
keep_slashes | If set, slashes are not encoded. |
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.
bool fz::remove_file | ( | native_string const & | name | ) |
remove the specified file.
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)
bool fz::same_type | ( | event_base const & | ev | ) |
Used as lightweight RTTI alternative during dispatch
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
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.
std::string fz::socket_error_string | ( | int | error | ) |
Gets a symbolic name for socket errors.
For example, error_string(EAGAIN) == "EAGAIN"
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.
cmd_with_args | The full path of the program to execute and any additional arguments |
true
even if the process cannot be started. 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:
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:
bool fz::starts_with | ( | String const & | s, |
String const & | beginning | ||
) |
Tests whether the first string starts with the second string.
insensitive_ascii | If true, comparison is case-insensitive |
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.
std::vector<std::string> fz::strtok | ( | std::string_view const & | tokens, |
std::string_view const & | delims, | ||
bool const | ignore_empty = true |
||
) |
Tokenizes string.
delims | the delimiters to look for |
ignore_empty | If true, empty tokens are omitted in the output |
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.
delims | the delimiters to look for |
ignore_empty | If true, empty tokens are omitted in the output |
native_string fz::to_native | ( | std::string_view const & | in | ) |
Converts std::string to native_string.
native_string fz::to_native | ( | std::wstring_view const & | in | ) |
Convert std::wstring to native_string.
std::string fz::to_string | ( | std::wstring_view const & | in | ) |
Converts from std::wstring into std::string in system encoding.
std::string fz::to_utf8 | ( | std::string_view const & | in | ) |
Converts from std::string in native encoding into std::string in UTF-8.
std::string fz::to_utf8 | ( | std::wstring_view const & | in | ) |
Converts from std::wstring in native encoding into std::string in UTF-8.
std::wstring fz::to_wstring | ( | std::string_view const & | in | ) |
Converts from std::string in system encoding into std::wstring.
std::wstring fz::to_wstring_from_utf8 | ( | std::string const & | in | ) |
Converts from std::string in UTF-8 into std::wstring.
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.
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
void fz::yield | ( | ) |
Relinquish control for a brief amount of time.
The exact duration is unspecified.