Namespace sys

POSIX and Linux system call wrappers.

Namespaces

namespace ipc
namespace literals
namespace shm
namespace terminal
namespace this_process
Routines implicitly applied to the currect process.

Types

using addr4_type = ::in_addr_t
IPv4 address representation unsigned integer type.
using addr6_type = u128
IPv6 address representation unsigned integer type.
using basic_event = struct ::pollfd
File descriptor event base class.
template <class Trans>
using basic_odirtree = basic_odirectory< Trans >
The same template as basic_odirectory.
using bstream = basic_bstream< char >
Alias to basic_bstream<char>.
using canonical_path = basic_canonical_path< char >
Specialisation of basic_canonical_path for char.
using cmessage_header = struct ::cmsghdr
Message header type for sending and receiving ancillary data through socket.
using code_type = int
Process exit code type.
using const_path = path_view
using cpu_set = dynamic_cpu_set
Use dynamic set by default, since it consumes less memory.
using device_type = ::dev_t
Alias to dev_t system type.
using dir_type = DIR
Alias to DIR system type.
using directory = basic_directory< ignore_hidden_files, copy_verbatim >
using dirent_type = struct ::dirent
Alias to dirent system type.
using f32 = float
4-byte floating point type.
using f64 = double
8-byte floating point type.
using family_type = socket_address_family
using fdstream = basic_fdstream< char >
Character based input/output file descriptor stream.
using fildesbuf = basic_fildesbuf< char >
Alias to basic_fildesbuf<char>.
using file_system_status_type = struct ::statvfs
using gid_type = ::gid_t
Alias for gid_t.
using group_iterator = groupstream::iterator
Iterator for groupstream.
using group_type = struct ::group
Alias to group system type.
using i16 = ::std::int16_t
2-byte signed integer type.
using i32 = ::std::int32_t
4-byte signed integer type.
using i64 = ::std::int64_t
8-byte signed integer type.
using i8 = ::std::int8_t
1-byte signed integer type.
using id_type = ::id_t
using idirectory = basic_idirectory< ignore_hidden_files >
Directory entry input stream that ignores all hidden files during traversal.
template <class T>
using idirectory_iterator = basic_istream_iterator< idirectory, T >
Directory entry input stream iterator.
using idirtree = basic_idirtree< ignore_hidden_files, ignore_hidden_dirs >
Recursive directory entry input stream that ignores all hidden files during traversal and does not recurse to hidden directories.
template <class T>
using idirtree_iterator = basic_istream_iterator< idirtree, T >
Recursive directory entry input stream iterator.
using ifaddr_message_container = sys::netlink_container< sys::ifaddr_message_header >
Netlink container for interface address messages.
using ifaddrs_type = struct ::ifaddrs
Alias to ifaddrs system type.
using ifdstream = basic_ifdstream< char >
Character based input file descriptor stream.
using ifinfo_message_container = sys::netlink_container< sys::ifinfo_message_header >
using inet4_type = struct ::in_addr
IPv4 Internet address type.
using inet6_type = struct ::in6_addr
IPv6 Internet address type.
using information_type = struct ::sysinfo
using inode_type = ::ino_t
Alias to ino_t system type.
using input_operator_type = std::function< bool(int, const std::string &)>
Function that parses command line argument.
using message_header = struct ::msghdr
Message header type for sending and receiving low-level socket messages.
using mode_type = ::mode_t
Alias for system file mode type mode_t.
using netlink_socket_address_type = ::sockaddr_nl
Netlink socket address type.
using odirectory = basic_odirectory< copy_verbatim >
Directory entry output stream that copies all files verbatim.
template <class T>
using odirectory_iterator = basic_ostream_iterator< odirectory, T >
Directory entry output stream iterator.
using odirtree = basic_odirtree< copy_recursively >
Directory entry output stream that copies all files and directories recursively.
template <class T>
using odirtree_iterator = basic_ostream_iterator< odirtree, T >
Directory entry output stream iterator.
using ofdstream = basic_ofdstream< char >
Character based output file descriptor stream.
using offset_type = ::off_t
Alias to off_t system type.
using packetbuf = basic_packetbuf< char >
Alias to basic_packetbuf<char>.
using passwd_type = struct ::passwd
Alias to passwd system type.
using path = basic_path< char >
Specialisation of basic_path for char.
using pid_type = ::pid_t
Alias for pid_t;.
using poll_event_base = struct ::epoll_event
File descriptor event base class.
using port_type = ::in_port_t
Socket port type.
using prefix_type = unsigned int
Network prefix type.
using resource_limit_type = struct ::rlimit
using resource_usage_type = struct ::rusage
using sa_family_type = ::sa_family_t
Socket address family type.
using scheduling_policy_parameter = ::sched_param
using shm_type = int
Alias for shared memory ID type.
using shmembuf = basic_shmembuf< char >
Instantiation of basic_shmembuf for char.
using sigaction_type = struct ::sigaction
Alias for sigaction system type.
using siginfo_type = ::siginfo_t
Alias for signinfo_t;.
using signal_info_type = ::siginfo_t
Alias for siginfo_t system type.
using signal_type = int
Alias for signal type.
using size_type = ::std::size_t
Alias to std::size_t.
using socket_address_type = struct ::sockaddr
Socket address type.
using socket_length_type = ::socklen_t
Socket address length type.
using sockinet4_type = struct ::sockaddr_in
IPv4 socket address type.
using sockinet6_type = struct ::sockaddr_in6
IPv6 socket address type.
using stat_type = struct ::stat
Alias to stat system type.
using time_spec_type = ::timespec
using time_value_type = ::timeval
using u16 = ::std::uint16_t
2-byte unsigned integer type.
using u32 = ::std::uint32_t
4-byte unsigned integer type.
using u64 = ::std::uint64_t
8-byte unsigned integer type.
using u8 = ::std::uint8_t
1-byte unsigned integer type.
using uid_type = ::uid_t
Alias for uid_t.
using unix_socket_address_type = ::sockaddr_un
Unix socket address type.
using user_credentials = struct ::ucred
Alias to ucred system type.
using user_iterator = userstream::iterator
Iterator for userstream.

Enumerations

enum advise_type
Memory mapping advices.
enum byte_order
enum calls: long
enum capabilities: u32
enum clocks: ::clockid_t
enum errors: int
enum event: decltype(poll_event_base::events)
Input/output events.
enum fd_flag: int
File descriptor flags.
enum file_attribute_flags: int
enum file_attribute_options
enum file_lock_type: int
File lock types.
enum file_type: mode_type
enum host_errc: int
enum host_flags: int
enum host_name_flags: int
enum ifaddr_attribute: u32
Interface address attributes.
enum ifaddr_message_type: u16
Interface address message types.
enum ifinfo_attribute: u32
enum ifinfo_message_type: u16
enum map_flag: int
Memory mapping flags.
enum mount_flags: int
enum namespace_type
enum netlink_message_flags: u16
Netlink message flags.
enum netlink_message_type: u16
Netlink message types.
enum netlink_protocol
enum network_interface_flags: u16
enum no_init
enum opcode_type: u8
WebSocket Opcode numbers.
enum open_flag: int
Flags used when opening file.
enum options: int
enum page_flag: int
Memory page access control flags.
enum path_flag: int
Path flags.
enum path_options: int
enum pipe_flag: int
File descriptor pipe flags.
enum process_flag: int
Flags used by clone(2) system call.
enum remap_flags: int
enum resources: int
enum scheduling_policies
enum secure_computing_modes
enum security_bits: u32
enum seek_origin: int
Origin of file seek operations.
enum semaphore_type: int
The scope of semaphore (process/thread).
enum shutdown_flag: int
Socket shutdown options.
enum signal: signal_type
Process signals.
enum socket_address_family: sa_family_type
Socket address families.
enum socket_type
Socket types.
enum string_options: int
enum sync_flag
Memory mapping synchronisation flags.
enum unmount_flags: int
enum unshare_flag: int
enum wait_flags: int
Flags used by waitid(2) system call.

Classes

class sys::argstream
Output stream of command line arguments.
template <class T>
class sys::array_view
class sys::array_view< void >
class sys::bad_argument
Invalid command line argument error.
class sys::bad_call
An exception that is thrown when a system call returns -1.
template <class Ch, class Tr = std::char_traits<Ch>>
class sys::basic_argbuf
Stream buffer for command line arguments.
template <class Ch, class Tr = std::char_traits<Ch>, class Size = u32>
class sys::basic_bstream
Input/output stream that reads/writes everything in binary format with network byte order.
template <class Ch, class Tr = std::char_traits<Ch>, class Alloc = std::allocator<Ch>>
class sys::basic_canonical_path
Canonical path that is always absolute and real.
template <class FilePred, class Trans>
class sys::basic_directory
Directory entry input/output stream.
template <class Ch, class Tr = std::char_traits<Ch>, class Fd = sys::fildes>
class sys::basic_fdstream
Input/output stream that reads/writes to/from file descriptor.
template <class Ch, class Tr = std::char_traits<Ch>, class Fd = sys::fildes>
class sys::basic_fildesbuf
Stream buffer that writes and reads from file descriptor.
template <class FilePred>
class sys::basic_idirectory
Directory entry input stream.
template <class FilePred, class DirPred>
class sys::basic_idirtree
Recursive directory entry input stream.
template <class Ch, class Tr = std::char_traits<Ch>, class Fd = sys::fildes>
class sys::basic_ifdstream
Input stream that reads from file descriptor.
template <class Ch, class Tr>
class sys::basic_ipacket_guard
Guard object that preserves packet buffer state upon failure.
template <class Stream, class Value>
class sys::basic_istream_iterator
Input stream iterator that works with any stream, not just std::istream.
template <class Trans>
class sys::basic_odirectory
Directory entry output stream.
template <class Ch, class Tr = std::char_traits<Ch>, class Fd = sys::fildes>
class sys::basic_ofdstream
Output stream that writes to file descriptor.
template <class Stream, class Value>
class sys::basic_ostream_iterator
Output stream iterator that works with any stream, not just std::ostream.
template <class Ch, class Tr = std::char_traits<Ch>>
class sys::basic_packetbuf
Stream buffer that can reads/writes data in packets with arbitrary header.
template <class Ch, class Tr = std::char_traits<Ch>, class Alloc = std::allocator<Ch>>
class sys::basic_path
File system path template which is a std::string with additional methods.
template <class Ch, class Tr = std::char_traits<Ch>>
class sys::basic_shmembuf
Shared memory stream buffer with synchronisation via process_semaphore.
template <class Ch, class Tr = std::char_traits<Ch>>
class sys::basic_websocketbuf
Stream buffer that encodes/decodes its contents using WebSocket protocol.
class sys::bridge_interface
class sys::byte_buffer
Byte buffer which uses direct memory allocation for maximum performance.
class sys::c_string
Immutable string with unknown size.
class sys::c_string_array_view
class sys::cache
System caches.
class sys::cache_level
A particular level of cache.
class sys::clock
class sys::condition_variable
class sys::const_string
Immutable string with known size.
template <class T>
class sys::cstring_iterator
Iterator for C-string arrays frequently used in system programming.
class sys::directory_entry
Directory entry.
class sys::dirstream
Base class for all directory streams.
class sys::dynamic_cpu_set
class sys::epoll_event
File descriptor event wrapper for event_poller.
class sys::error
class sys::ethernet_address
class sys::event_file_descriptor
class sys::event_poller
File descriptor poller.
template <class Base, size_t N>
class sys::field_iterator
Iterator for containers of tuples.
class sys::fildes
File descriptor wrapper.
class sys::fildes_pair
A pair of file descriptors.
template <class T>
class sys::file_attribute_iterator
class sys::file_attributes
class sys::file_descriptor_view
class sys::file_mode
File mode wrapper.
class sys::file_mutex
File-based mutex.
class sys::file_status
File status class that wraps stat system type.
class sys::file_system_status
class sys::futex
class sys::group
System user group.
class sys::groupstream
Input stream of system groups.
class sys::host
class sys::host_error_category
class sys::host_iterator
class sys::hosts
class sys::ifaddr_message
Netlink interaface address message.
class sys::ifaddr_message_header
Netlink interface address message header.
class sys::ifinfo_message
class sys::ifinfo_message_header
class sys::ifinfo_request
class sys::information
template <class Addr>
class sys::interface_address
Network interface address.
class sys::interface_address_iterator
Iterator for interface addresses of the computer.
class sys::interface_addresses
Interface addresses container.
template <class T>
class sys::interface_socket_address
template <class T, class Delim = const char*, class Ch = char, class Tr = std::char_traits<Ch>>
class sys::intersperse_iterator
Iterator that intersperses output values by specified delimiter.
class sys::ios_guard
I/O stream state guard.
class sys::ipv4_address
IPv4 address class.
class sys::ipv4_socket_address
IPv4 socket address wrapper.
class sys::ipv6_address
IPv6 address class.
class sys::ipv6_socket_address
IPv4 socket address wrapper.
template <class T>
class sys::iterator_pair
Container interface for two iterators.
template <class T>
class sys::key_value
Command line argument encoded as key=value pair.
class sys::log
class sys::log_message
Write formatted log message.
class sys::memory_file_allocator
class sys::memory_file_descriptor
template <class T>
class sys::memory_mapping
Memory mapping for files.
template <class T>
class sys::memory_ptr
class sys::mutex
template <class T>
class sys::netlink_attribute_iterator
Iterator for netlink message attributes.
template <class T>
class sys::netlink_container
Container for netlink messages.
class sys::netlink_header
Netlink message header.
template <class T>
class sys::netlink_message_iterator
Iterator for netlink multipart messages.
class sys::netlink_socket
class sys::netlink_socket_address
class sys::network_interface
class sys::osysstream
Output stream for standard file descriptors that uses basic_fildesbuf as stream buffer.
class sys::path_view
class sys::pipe
A pipe constructed with pipe(2) system call.
class sys::posix_semaphore
Semaphore, implemented using POSIX system calls.
class sys::process
System process with std::thread interface.
class sys::process_group
A group of processes.
class sys::process_group_view
class sys::process_semaphore
Process semaphore.
class sys::process_view
class sys::recursive_spin_mutex
Spin mutex that can be lock multiple times by the same thread.
class sys::resource_limit
class sys::resource_usage
template <class A>
class sys::rtattributes
Netlink route attributes.
class sys::sha1
Computes bytes digest using SHA-1 algorithm.
class sys::sha2_224
class sys::sha2_256
class sys::sha2_384
class sys::sha2_512
class sys::sha2_512_224
class sys::sha2_512_256
class sys::sha2_512_base
class sys::sha2_base
class sys::shared_byte_buffer
template <class T>
class sys::shared_memory_segment
A container that stores its elements in shared memory.
class sys::shared_memory_segment_status
A wrapper for shmid_ds system structure.
class sys::signal_action
Signal callback.
class sys::signal_guard
Blocks/unblocks specified signals upon creation/destruction.
class sys::signal_information
class sys::signal_set
Signal set.
template <class Mutex>
class sys::simple_lock
A lock guard with lock and unlock methods.
class sys::socket
Socket wrapper.
class sys::socket_address
Socket address wrapper.
class sys::socket_address_view
class sys::spin_mutex
Fast mutex that does not use system calls.
class sys::splice
class sys::stack_trace
class sys::static_cpu_set
class sys::string
Mutable string with known capacity.
template <class Address>
class sys::subnet_iterator
Iterator, that traverses IP addresses in a subnetwork.
class sys::sysv_semaphore
Semaphore, implemented using System V system calls.
class sys::temporary_file
class sys::thread_semaphore
Thread semaphore.
class sys::time_of_day
class sys::time_spec
class sys::time_value
class sys::two_way_pipe
Two-way pipe implemented as two one-way pipes.
class sys::u128
class sys::unix_socket_address
IPv4 socket address wrapper.
template <class Mutex>
class sys::unlock_guard
The inverse of standard lock guard.
class sys::user
System user.
class sys::user_context
Process context to be used for user-space context switching.
class sys::userstream
Input stream of system users.
class sys::veth_interface

Structs

struct sys::backtrace_symbol
struct sys::child_page
struct sys::copy_recursively
Copy files and directories recursively.
struct sys::copy_verbatim
Copy files without changing their names.
struct sys::fd_type
Wrapper for system file descriptor type (int).
template <class T>
struct sys::fildes_streambuf_traits
Base class for File descriptor streambuf_traits.
struct sys::ignore_first_argument
Ignores nought command line argument, which usually equals executable name.
struct sys::ignore_hidden_dirs
Do not recurse to hidden directories when traversing directories.
struct sys::ignore_hidden_files
Do not include hidden file when traversing directories.
struct sys::io_vector
template <class Address>
struct sys::ipaddr_traits
IP-address generic functions.
struct sys::ipaddr_traits< ipv4_address >
Specialisation of ipaddr_traits for ipv4_address.
struct sys::ipaddr_traits< ipv6_address >
Specialisation of ipaddr_traits for ipv6_address.
template <class T>
struct sys::is_flag
struct sys::is_flag< fd_flag >
struct sys::is_flag< map_flag >
struct sys::is_flag< netlink_message_flags >
struct sys::is_flag< network_interface_flags >
struct sys::is_flag< open_flag >
struct sys::is_flag< page_flag >
struct sys::is_flag< path_flag >
struct sys::is_flag< pipe_flag >
struct sys::is_flag< process_flag >
struct sys::is_flag< sync_flag >
struct sys::is_flag< unshare_flag >
struct sys::is_flag< wait_flags >
template <class T>
struct sys::memory_view
struct sys::parent_page
struct sys::poll_event
File descriptor event wrapper for poll(2) system call.
struct sys::process_status
A process_status object that tells how the process was terminated.
template <class T>
struct sys::streambuf_traits
Traits that abstract read and write operations for stream buffers.
struct sys::streambuf_traits< fd_type >
Stream buffer traits for bare fd_type.
struct sys::streambuf_traits< fildes >
Stream buffer traits for fildes.
struct sys::streambuf_traits< fildes_pair >
Specialisation of streambuf_traits for fildes_pair.
struct sys::streambuf_traits< socket >
Stream buffer traits for socket.
template <class Ch>
struct sys::streamptr
Object that stores streambuf internal state.
struct sys::u128_div

Unions

template <class T, class Ch = char>
union sys::bytes
Container, that uses object binary representation as its contents.
union sys::websocket_frame
WebSocket frame.

Variables

constexpr const char file_separator
Path components separator.
host_error_category host_category
constexpr const char path_separator
Path separator in environment variables.

Functions

UNISTDX_FLAGS(security_bits)
UNISTDX_FLAGS(log::options)
UNISTDX_FLAGS(socket::message_flags)
UNISTDX_FLAGS(shutdown_flag)
UNISTDX_FLAGS(host_name_flags)
UNISTDX_FLAGS(host_flags)
UNISTDX_FLAGS(signal_action::flag)
UNISTDX_FLAGS(memory_file_descriptor::flag)
UNISTDX_FLAGS(remap_flags)
UNISTDX_FLAGS(event_file_descriptor::flag)
UNISTDX_FLAGS(unmount_flags)
UNISTDX_FLAGS(mount_flags)
UNISTDX_FLAGS(file_attribute_options)
UNISTDX_FLAGS(file_attribute_flags)
template <class Ch, class Tr>
append_payload(basic_packetbuf< Ch, Tr > & dest, basic_packetbuf< Ch, Tr > & src, std::streamsize off = 0) -> void
backtrace(int fd) -> void
Print calling process function call trace (if supported).
backtrace_on_signal(int sig) -> void
backtrace_on_terminate() -> void
base64_decode(const char * first, const char * last, char * result) -> size_t
Decode BASE64 byte sequence.
base64_decode(const char * first, size_t n, char * result) -> UNISTDX_FLATTEN size_t
Decode BASE64 byte sequence.
base64_encode(const char * first, const char * last, char * result) -> void
Encode byte sequence with BASE64.
base64_encode(const char * first, size_t n, char * result) -> UNISTDX_FLATTEN void
Encode byte sequence with BASE64.
base64_encoded_size(size_t len) -> size_t
The length of len bytes sequence encoded in BASE64.
base64_max_decoded_size(size_t len) -> UNISTDX_CONST size_t
The length of len bytes sequence decoded from BASE64.
template <class T>
bit_count(T value) -> unsigned int
Count the number of bits that are set in value.
bit_count< unsigned int >(unsigned int value) -> unsigned int
Specialisation for unsigned int.
bit_count< unsigned long >(unsigned long value) -> unsigned int
Specialisation for unsigned long.
bit_count< unsigned long long >(unsigned long long value) -> unsigned int
Specialisation for unsigned long long.
byte_swap(unsigned __int128 x) -> unsigned __int128
Specialisation for built-in 16-byte unsigned integer.
byte_swap(u128 x) -> u128
Specialisation for 16-byte unsigned integer.
template <class T>
byte_swap(T n) -> T
Byte-swapping function.
byte_swap< u16 >(u16 n) -> constexpr u16
Specialisation for 2-byte unsigned integer.
byte_swap< u32 >(u32 n) -> constexpr u32
Specialisation for 4-byte unsigned integer.
byte_swap< u64 >(u64 n) -> constexpr u64
Specialisation for 8-byte unsigned integer.
byte_swap< u8 >(u8 n) -> constexpr u8
Specialisation for 1-byte unsigned integer.
template <class ... Args>
call(calls n, Args ... args) -> long
template <class T>
check(T ret, T bad_ret) -> T
template <class T>
check(T * ret) -> T *
template <class T>
check(T ret) -> T
copy_file(const path & src, const path & dest) -> void
Copy file using the most optimal system call.
template <class It>
delete_each(It first, It last) -> void
demangle(const char * symbol, string & buf) -> const char *
disable_process_accounting() -> void
div(const u128 & lhs, const u128 & rhs) -> u128_div
template <class T>
downcast(T x) -> constexpr std::underlying_type< T >::type
dump_core() -> void
Dump core.
enable_process_accounting(c_string path) -> void
template <class Addr, class Result>
enumerate_ifaddrs(Result result) -> void
Copy all addresses of the specified type to result.
exit(int status) -> void
find_group(const char * name, group & result) -> bool
Find group in system database by name name and store in result.
find_group(gid_type id, group & result) -> bool
Find group in system database by id id and store in result.
find_user(const char * name, user & result) -> bool
Find user in system database by name name and store in result.
find_user(uid_type id, user & result) -> bool
Find user in system database by id id and store in result.
get(string_options name) -> string
get(string_options name, string & buf) -> void
get(fd_type fd, path_options name) -> long
get(c_string path, path_options name) -> long
get(options name, long default_value) -> long
get(options name) -> long
get_file_type(const path & dirname, const directory_entry & entry) -> file_type
Reliably get file type of a directory entry.
host_name(const socket_address & address, host_name_flags flags = host_name_flags{}) -> string
io_concurrency() -> unsigned
Always returns 1.
is_a_terminal(sys::fd_type f) -> bool
Returns true, if file descriptor f refers to a terminal.
template <class T>
is_basic() -> constexpr bool
is_network_byte_order() -> constexpr bool
Returns true if this archiecture uses network byte order (little-endian).
template <class T>
make_bytes(T rhs) -> constexpr bytes< T >
Construct byte sequence from object rhs.
template <class Ch, class Tr, class Alloc>
make_canonical(std::basic_string< Ch, Tr, Alloc > && rhs) -> std::unique_ptr< char[]>
Make path rhs canonical.
template <class Ch, class Tr, class Alloc>
make_canonical(const std::basic_string< Ch, Tr, Alloc > & rhs) -> std::unique_ptr< char[]>
Make path rhs canonical.
template <class T>
make_canonical(const path & rhs) -> std::unique_ptr< char[]>
Make path rhs canonical.
template <class T>
make_canonical(path && rhs) -> std::unique_ptr< char[]>
Make path rhs canonical.
make_canonical(const char * rhs) -> std::unique_ptr< char[]>
Make path rhs canonical.
make_error_condition(host_errc e) -> std::error_condition
template <class ... Args>
make_fields(const Args &... args) -> bits::Field< Args... >
template <class ... Args>
make_func(const char * name, const Args &... args) -> bits::Function< Args... >
template <class T>
make_key_value(const std::string & key, T & value) -> key_value< T >
Helper function to construct key-value pair.
template <class ... Args>
make_memory_file_allocator(Args &&... args) -> byte_buffer::allocator_ptr
template <class ... Args>
make_object(const Args &... args) -> bits::Object< Args... >
template <class ... Args>
make_sentence(const Args &... args) -> bits::Sentence< Args... >
template <class T>
make_view(T first, T last) -> iterator_pair< T >
Construct iterator pair from first and last.
template <size_t N, class C>
make_view(C & cont) -> iterator_pair< field_iterator< typename C::iterator, N > >
Construct field iterator view from container cont.
template <size_t N, class T>
make_view(T first, T last) -> iterator_pair< field_iterator< T, N > >
Construct field iterator view from first and last.
max_priority(scheduling_policies policy) -> int
template <class ... Args>
message(log::facilities facility, log::levels level, const char * format, Args ... args) -> void
template <class ... Args>
message(const char * format, Args ... args) -> void
template <class ... Args>
message(log::priority prio, const char * format, Args ... args) -> void
min_priority(scheduling_policies policy) -> int
mkdirs(const path & root, const path & relative_path, file_mode m = 0755) -> void
Make directories recursively.
mkdirs(path dir, file_mode m = 0755, path::size_type offset = 1) -> void
Make directories recursively.
native_byte_order() -> constexpr byte_order
template <class T>
operator!(T a) -> constexpr std::enable_if< is_flag< T >::value, bool >::type
operator!=(const fildes & lhs, fd_type rhs) -> bool
Compare file descriptors.
operator!=(fd_type lhs, const fildes & rhs) -> bool
Compare file descriptors.
operator!=(const u128 & lhs, const u128 & rhs) -> constexpr bool
operator!=(errors b, std::errc a) -> bool
operator!=(std::errc a, errors b) -> bool
operator!=(const ethernet_address & lhs, const ethernet_address & rhs) -> bool
template <class T>
operator!=(const memory_mapping< T > & lhs, const memory_mapping< T > & rhs) -> bool
operator!=(event a, decltype(poll_event_base::events) b) -> bool
operator!=(decltype(poll_event_base::events) a, event b) -> bool
operator%(const u128 & lhs, const u128 & rhs) -> u128
operator&(const static_cpu_set & a, const static_cpu_set & b) -> static_cpu_set
operator&(const u128 & lhs, const u128 & rhs) -> constexpr u128
operator&(decltype(poll_event_base::events) a, event b) -> event
operator&(event a, decltype(poll_event_base::events) b) -> event
operator&(event a, event b) -> event
template <class T>
operator&(T a, T b) -> constexpr std::enable_if< is_flag< T >::value, T >::type
template <class T>
operator&=(T & a, T b) -> constexpr std::enable_if< is_flag< T >::value, T >::type
operator+(const u128 & lhs, const u128 & rhs) -> constexpr u128
operator-(const u128 & lhs, const u128 & rhs) -> constexpr u128
operator/(const u128 & lhs, const u128 & rhs) -> u128
operator<(const u128 & lhs, const u128 & rhs) -> constexpr bool
operator<(const ethernet_address & lhs, const ethernet_address & rhs) -> bool
template <class T>
operator<(const memory_mapping< T > & lhs, const memory_mapping< T > & rhs) -> bool
operator<<(std::ostream & out, capabilities rhs) -> std::ostream &
operator<<(std::ostream & out, const group & rhs) -> std::ostream &
Print group in /etc/group format.
operator<<(std::ostream & out, const user & rhs) -> std::ostream &
Print user in /etc/passwd format.
operator<<(std::ostream & out, const stack_trace & rhs) -> std::ostream &
operator<<(std::ostream & out, const backtrace_symbol & rhs) -> std::ostream &
operator<<(bstream & out, const unix_socket_address & rhs) -> bstream &
operator<<(std::ostream & out, const unix_socket_address & rhs) -> std::ostream &
operator<<(bstream & out, const socket_address & rhs) -> bstream &
Put socket_address in binary form.
operator<<(std::ostream & out, const socket_address & rhs) -> std::ostream &
Print textual representation of the socket_address.
operator<<(std::ostream & out, const socket & rhs) -> std::ostream &
Print socket file descriptor and status.
operator<<(bstream & out, const netlink_socket_address & rhs) -> bstream &
operator<<(std::ostream & out, const netlink_socket_address & rhs) -> std::ostream &
operator<<(std::ostream & out, const ifaddr_attribute & rhs) -> std::ostream &
Print attribute name for debugging.
operator<<(bstream & out, const ipv6_socket_address & rhs) -> bstream &
operator<<(std::ostream & out, const ipv6_socket_address & rhs) -> std::ostream &
operator<<(std::ostream & out, const ipv6_address & rhs) -> std::ostream &
Print textual representation of the address.
operator<<(bstream & out, const ipv4_socket_address & rhs) -> bstream &
operator<<(std::ostream & out, const ipv4_socket_address & rhs) -> std::ostream &
operator<<(std::ostream & out, ipv4_address rhs) -> std::ostream &
Print textual representation of the address.
template <class T>
operator<<(std::ostream & out, const interface_socket_address< T > & rhs) -> std::ostream &
operator<<(std::ostream & out, const socket_address_family & rhs) -> std::ostream &
Print family name for debugging.
operator<<(bstream & out, socket_address_family rhs) -> bstream &
Put socket address family in a portable way.
operator<<(std::ostream & out, const ethernet_address & rhs) -> std::ostream &
Print textual representation of the address.
template <class T, class B>
operator<<(std::ostream & out, const bytes< T, B > & rhs) -> std::ostream &
Print byte sequence in hexadecimal form.
operator<<(std::ostream & out, const signal rhs) -> std::ostream &
Output signal name.
operator<<(std::ostream & out, const process_status & rhs) -> std::ostream &
Output PID, exit status, exit code/termination signal.
operator<<(std::ostream & out, const process & rhs) -> std::ostream &
Output process ID and process group ID.
operator<<(std::ostream & out, const dynamic_cpu_set & rhs) -> std::ostream &
operator<<(std::ostream & out, const static_cpu_set & rhs) -> std::ostream &
operator<<(std::ostream & out, const two_way_pipe & rhs) -> std::ostream &
Output both pipes.
operator<<(std::ostream & out, const poll_event & rhs) -> std::ostream &
Output file descriptor and event mask for debugging.
operator<<(std::ostream & out, const pipe & rhs) -> std::ostream &
Print pipe input and output file descriptors for debugging.
operator<<(std::ostream & out, const fd_type & rhs) -> std::ostream &
operator<<(std::ostream & out, const epoll_event & rhs) -> std::ostream &
Output file descriptor and event mask for debugging.
operator<<(std::ostream & out, const file_type & rhs) -> std::ostream &
Print file type as a character, as in ls(1) command.
operator<<(std::ostream & out, const file_status & rhs) -> std::ostream &
Print file status for debugging (the format is similar to ls(1)).
operator<<(std::ostream & out, const file_mode & rhs) -> std::ostream &
Print file mode bits in symbolic form.
operator<<(std::ostream & out, const websocket_frame & rhs) -> std::ostream &
Output WebSocket frame header field for debugging.
operator<<(std::ostream & out, const u128 & rhs) -> std::ostream &
operator<<(const u128 & lhs, const u128 & rhs) -> u128
operator<<(std::ostream & out, const c_string_array_view & rhs) -> std::ostream &
operator<<(std::ostream & out, const string & rhs) -> std::ostream &
operator<<(std::ostream & out, const c_string & rhs) -> std::ostream &
operator<=(const u128 & lhs, const u128 & rhs) -> constexpr bool
operator<=(const ethernet_address & lhs, const ethernet_address & rhs) -> bool
template <class T>
operator<=(const memory_mapping< T > & lhs, const memory_mapping< T > & rhs) -> bool
operator==(const dynamic_cpu_set & a, const dynamic_cpu_set & b) -> bool
operator==(const fildes & lhs, fd_type rhs) -> bool
Compare file descriptors.
operator==(fd_type lhs, const fildes & rhs) -> bool
Compare file descriptors.
operator==(const u128 & lhs, const u128 & rhs) -> constexpr bool
operator==(errors b, std::errc a) -> bool
operator==(std::errc a, errors b) -> bool
operator==(const ethernet_address & lhs, const ethernet_address & rhs) -> bool
template <class T>
operator==(const memory_mapping< T > & lhs, const memory_mapping< T > & rhs) -> bool
operator==(event a, decltype(poll_event_base::events) b) -> bool
operator==(decltype(poll_event_base::events) a, event b) -> bool
operator>(const u128 & lhs, const u128 & rhs) -> constexpr bool
operator>(const ethernet_address & lhs, const ethernet_address & rhs) -> bool
template <class T>
operator>(const memory_mapping< T > & lhs, const memory_mapping< T > & rhs) -> bool
operator>=(const u128 & lhs, const u128 & rhs) -> constexpr bool
operator>=(const ethernet_address & lhs, const ethernet_address & rhs) -> bool
template <class T>
operator>=(const memory_mapping< T > & lhs, const memory_mapping< T > & rhs) -> bool
operator>>(std::istream & in, capabilities & rhs) -> std::istream &
operator>>(bstream & in, unix_socket_address & rhs) -> bstream &
operator>>(std::istream & in, unix_socket_address & rhs) -> std::istream &
operator>>(bstream & in, socket_address & rhs) -> bstream &
Get socket_address in binary form.
operator>>(std::istream & in, socket_address & rhs) -> std::istream &
Parse textual representation of the socket_address.
operator>>(bstream & in, netlink_socket_address & rhs) -> bstream &
operator>>(std::istream & in, netlink_socket_address & rhs) -> std::istream &
operator>>(bstream & in, ipv6_socket_address & rhs) -> bstream &
operator>>(std::istream & in, ipv6_socket_address & rhs) -> std::istream &
operator>>(std::istream & in, ipv6_address & rhs) -> std::istream &
Parse textual representation of the address.
operator>>(bstream & in, ipv4_socket_address & rhs) -> bstream &
operator>>(std::istream & in, ipv4_socket_address & rhs) -> std::istream &
operator>>(std::istream & in, ipv4_address & rhs) -> std::istream &
Parse textual representation of the address.
operator>>(bstream & in, socket_address_family & rhs) -> bstream &
Get socket address family in a portable way.
operator>>(std::istream & in, ethernet_address & rhs) -> std::istream &
Parse textual representation of the address.
operator>>(std::istream & in, dynamic_cpu_set & rhs) -> std::istream &
operator>>(std::istream & in, static_cpu_set & rhs) -> std::istream &
operator>>(std::istream & in, fd_type & rhs) -> std::istream &
operator>>(const u128 & lhs, const u128 & rhs) -> u128
operator^(const static_cpu_set & a, const static_cpu_set & b) -> static_cpu_set
operator^(const u128 & lhs, const u128 & rhs) -> constexpr u128
template <class T>
operator^(T a, T b) -> constexpr std::enable_if< is_flag< T >::value, T >::type
template <class T>
operator^=(T & a, T b) -> constexpr std::enable_if< is_flag< T >::value, T >::type
operator|(log::facilities a, log::priority b) -> constexpr inline ::sys::log::priority
operator|(log::priority a, log::facilities b) -> constexpr inline ::sys::log::priority
operator|(log::levels a, log::priority b) -> constexpr inline ::sys::log::priority
operator|(log::priority a, log::levels b) -> constexpr inline ::sys::log::priority
operator|(log::levels a, log::facilities b) -> constexpr inline ::sys::log::priority
operator|(log::facilities a, log::levels b) -> constexpr inline ::sys::log::priority
operator|(const static_cpu_set & a, const static_cpu_set & b) -> static_cpu_set
operator|(const u128 & lhs, const u128 & rhs) -> constexpr u128
operator|(event a, decltype(poll_event_base::events) b) -> event
operator|(decltype(poll_event_base::events) a, event b) -> event
operator|(event a, event b) -> event
template <class T>
operator|(T a, T b) -> constexpr std::enable_if< is_flag< T >::value, T >::type
template <class T>
operator|=(T & a, T b) -> constexpr std::enable_if< is_flag< T >::value, T >::type
operator~(static_cpu_set && rhs) -> static_cpu_set &&
operator~(const static_cpu_set & rhs) -> static_cpu_set
operator~(event a) -> event
template <class T>
operator~(T a) -> constexpr std::enable_if< is_flag< T >::value, T >::type
page_size() -> size_type
Get system page size.
parse_arguments(int argc, char * argv, input_operator_type * input_operators) -> void
parse_arguments(int argc, const char * argv, input_operator_type * input_operators) -> void
print(std::ostream & out, const char * message, const stack_trace & trace) -> void
process_group_priority(id_type pgrp) -> int
process_group_priority(id_type pgrp, int value) -> void
send(signal s, pid_type p) -> UNISTDX_DEPRECATED void
Send signal s to process p.
service_name(port_type port, host_name_flags flags = host_name_flags{}) -> string
template <class T>
socket_address_cast(const socket_address & rhs) -> const T &
template <class T>
socket_address_cast(socket_address & rhs) -> T &
template <class T>
socket_address_reinterpret_cast(const socket_address & rhs) -> const T &
template <class T>
socket_address_reinterpret_cast(socket_address & rhs) -> T &
string_to_capability(const char * s) -> capabilities
supergroup() -> constexpr gid_type
Superuser group ID. Always returns 0.
superuser() -> constexpr uid_type
Superuser ID. Always returns 0.
supports(open_flag rhs) -> constexpr bool
Check if flag rhs is supported by operating system.
swap(socket & lhs, socket & rhs) -> void
Overload of std::swap for socket.
template <class T>
swap(shared_memory_segment< T > & lhs, shared_memory_segment< T > & rhs) -> void
Overload of std::swap for shared_memory_segment.
swap(process_group & lhs, process_group & rhs) -> void
Overload of std::swap for process_group.
swap(process & lhs, process & rhs) -> void
Overload of std::swap for process.
swap(two_way_pipe & lhs, two_way_pipe & rhs) -> void
Overload of std::swap for two_way_pipe.
swap(pipe & lhs, pipe & rhs) -> void
Overload of std::swap for pipe.
template <class T>
swap(memory_ptr< T > & a, memory_ptr< T > & b) -> void
template <class T>
swap(memory_mapping< T > & lhs, memory_mapping< T > & rhs) -> void
Overload of std::swap for byte_buffer.
template <class Ch, class Tr, class Fd>
swap(basic_fildesbuf< Ch, Tr, Fd > & lhs, basic_fildesbuf< Ch, Tr, Fd > & rhs) -> void
Overload of std::swap for basic_fildesbuf.
swap(fildes_pair & lhs, fildes_pair & rhs) -> void
Overload of std::swap for fildes_pair.
swap(fildes & lhs, fildes & rhs) -> void
Overload of std::swap for fildes.
template <class Ch, class Tr, class Alloc>
swap(basic_path< Ch, Tr, Alloc > & lhs, basic_path< Ch, Tr, Alloc > & rhs) -> void
Overload of std::swap for basic_path.
template <class Ch, class Tr, class Alloc>
swap(basic_canonical_path< Ch, Tr, Alloc > & lhs, basic_canonical_path< Ch, Tr, Alloc > & rhs) -> void
Overload of std::swap for basic_canonical_path.
swap(byte_buffer & lhs, byte_buffer & rhs) -> void
Overload of std::swap for byte_buffer.
sync_file_systems() -> void
Write file system cache to disk. Affects all mounted file systems.
thread_concurrency() -> unsigned
Returns maximum number of threads for the system.
template <class T>
to_host_format(T n) -> constexpr T
Converts binary representation of n in network byte order to native byte order if needed.
template <class T>
to_network_format(T n) -> constexpr T
Converts binary representation of n in native byte order to network byte order if needed.
to_string(capabilities c) -> const char *
to_string(ifaddr_attribute rhs) -> const char *
Returns attribute name.
to_string(socket_address_family rhs) -> const char *
Get family name.
to_string(signal s) -> const char *
to_string(const u128 & rhs) -> std::string
to_string(errors e) -> const char *
user_priority(uid_type uid) -> int
user_priority(uid_type user, int value) -> void