jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
3 * Copyright (c) 2021-2022, Kenneth Myhra <kennethmyhra@serenityos.org>
4 * Copyright (c) 2021, Sam Atkins <atkinssj@serenityos.org>
5 *
6 * SPDX-License-Identifier: BSD-2-Clause
7 */
8
9#pragma once
10
11#include <AK/Error.h>
12#include <AK/Noncopyable.h>
13#include <AK/OwnPtr.h>
14#include <AK/StringView.h>
15#include <AK/Vector.h>
16#include <dirent.h>
17#include <fcntl.h>
18#include <grp.h>
19#include <netdb.h>
20#include <poll.h>
21#include <pwd.h>
22#include <signal.h>
23#include <spawn.h>
24#include <sys/ioctl.h>
25#include <sys/socket.h>
26#include <sys/stat.h>
27#include <sys/time.h>
28#include <sys/utsname.h>
29#include <sys/wait.h>
30#include <termios.h>
31#include <time.h>
32#include <utime.h>
33
34#if !defined(AK_OS_BSD_GENERIC) && !defined(AK_OS_ANDROID)
35# include <shadow.h>
36#endif
37
38#ifdef AK_OS_SOLARIS
39# include <sys/filio.h>
40# include <ucred.h>
41#endif
42
43namespace Core::System {
44
45#ifdef AK_OS_SERENITY
46ErrorOr<void> beep(Optional<size_t> tone);
47ErrorOr<void> pledge(StringView promises, StringView execpromises = {});
48ErrorOr<void> unveil(StringView path, StringView permissions);
49ErrorOr<void> unveil_after_exec(StringView path, StringView permissions);
50ErrorOr<void> sendfd(int sockfd, int fd);
51ErrorOr<int> recvfd(int sockfd, int options);
52ErrorOr<void> ptrace_peekbuf(pid_t tid, void const* tracee_addr, Bytes destination_buf);
53ErrorOr<void> mount(int source_fd, StringView target, StringView fs_type, int flags);
54ErrorOr<void> umount(StringView mount_point);
55ErrorOr<long> ptrace(int request, pid_t tid, void* address, void* data);
56ErrorOr<void> disown(pid_t pid);
57ErrorOr<void> profiling_enable(pid_t, u64 event_mask);
58ErrorOr<void> profiling_disable(pid_t);
59ErrorOr<void> profiling_free_buffer(pid_t);
60#else
61inline ErrorOr<void> unveil(StringView, StringView)
62{
63 return {};
64}
65inline ErrorOr<void> pledge(StringView, StringView = {}) { return {}; }
66#endif
67
68template<size_t N>
69ALWAYS_INLINE ErrorOr<void> pledge(char const (&promises)[N])
70{
71 return pledge(StringView { promises, N - 1 });
72}
73
74template<size_t NPromises, size_t NExecPromises>
75ALWAYS_INLINE ErrorOr<void> pledge(char const (&promises)[NPromises], char const (&execpromises)[NExecPromises])
76{
77 return pledge(StringView { promises, NPromises - 1 }, StringView { execpromises, NExecPromises - 1 });
78}
79
80template<size_t NPath, size_t NPermissions>
81ALWAYS_INLINE ErrorOr<void> unveil(char const (&path)[NPath], char const (&permissions)[NPermissions])
82{
83 return unveil(StringView { path, NPath - 1 }, StringView { permissions, NPermissions - 1 });
84}
85
86ALWAYS_INLINE ErrorOr<void> unveil(nullptr_t, nullptr_t)
87{
88 return unveil(StringView {}, StringView {});
89}
90
91#if !defined(AK_OS_BSD_GENERIC) && !defined(AK_OS_ANDROID)
92ErrorOr<Optional<struct spwd>> getspent();
93ErrorOr<Optional<struct spwd>> getspnam(StringView name);
94#endif
95
96#ifndef AK_OS_MACOS
97ErrorOr<int> accept4(int sockfd, struct sockaddr*, socklen_t*, int flags);
98#endif
99
100ErrorOr<void> sigaction(int signal, struct sigaction const* action, struct sigaction* old_action);
101#if defined(AK_OS_SOLARIS)
102ErrorOr<SIG_TYP> signal(int signal, SIG_TYP handler);
103#elif defined(AK_OS_BSD_GENERIC)
104ErrorOr<sig_t> signal(int signal, sig_t handler);
105#else
106ErrorOr<sighandler_t> signal(int signal, sighandler_t handler);
107#endif
108ErrorOr<struct stat> fstat(int fd);
109ErrorOr<int> fcntl(int fd, int command, ...);
110ErrorOr<void*> mmap(void* address, size_t, int protection, int flags, int fd, off_t, size_t alignment = 0, StringView name = {});
111ErrorOr<void> munmap(void* address, size_t);
112ErrorOr<int> anon_create(size_t size, int options);
113ErrorOr<int> open(StringView path, int options, mode_t mode = 0);
114ErrorOr<int> openat(int fd, StringView path, int options, mode_t mode = 0);
115ErrorOr<void> close(int fd);
116ErrorOr<void> ftruncate(int fd, off_t length);
117ErrorOr<struct stat> stat(StringView path);
118ErrorOr<struct stat> lstat(StringView path);
119ErrorOr<ssize_t> read(int fd, Bytes buffer);
120ErrorOr<ssize_t> write(int fd, ReadonlyBytes buffer);
121ErrorOr<void> kill(pid_t, int signal);
122ErrorOr<void> killpg(int pgrp, int signal);
123ErrorOr<int> dup(int source_fd);
124ErrorOr<int> dup2(int source_fd, int destination_fd);
125ErrorOr<DeprecatedString> ptsname(int fd);
126ErrorOr<DeprecatedString> gethostname();
127ErrorOr<void> sethostname(StringView);
128ErrorOr<DeprecatedString> getcwd();
129ErrorOr<void> ioctl(int fd, unsigned request, ...);
130ErrorOr<struct termios> tcgetattr(int fd);
131ErrorOr<void> tcsetattr(int fd, int optional_actions, struct termios const&);
132ErrorOr<int> tcsetpgrp(int fd, pid_t pgrp);
133ErrorOr<void> chmod(StringView pathname, mode_t mode);
134ErrorOr<void> lchown(StringView pathname, uid_t uid, gid_t gid);
135ErrorOr<void> chown(StringView pathname, uid_t uid, gid_t gid);
136ErrorOr<Optional<struct passwd>> getpwent(Span<char> buffer);
137ErrorOr<Optional<struct passwd>> getpwnam(StringView name);
138ErrorOr<Optional<struct group>> getgrnam(StringView name);
139ErrorOr<Optional<struct passwd>> getpwuid(uid_t);
140ErrorOr<Optional<struct group>> getgrent(Span<char> buffer);
141ErrorOr<Optional<struct group>> getgrgid(gid_t);
142ErrorOr<void> clock_settime(clockid_t clock_id, struct timespec* ts);
143ErrorOr<pid_t> posix_spawn(StringView path, posix_spawn_file_actions_t const* file_actions, posix_spawnattr_t const* attr, char* const arguments[], char* const envp[]);
144ErrorOr<pid_t> posix_spawnp(StringView path, posix_spawn_file_actions_t* const file_actions, posix_spawnattr_t* const attr, char* const arguments[], char* const envp[]);
145ErrorOr<off_t> lseek(int fd, off_t, int whence);
146ErrorOr<void> endgrent();
147
148struct WaitPidResult {
149 pid_t pid;
150 int status;
151};
152ErrorOr<WaitPidResult> waitpid(pid_t waitee, int options = 0);
153ErrorOr<void> setuid(uid_t);
154ErrorOr<void> seteuid(uid_t);
155ErrorOr<void> setgid(gid_t);
156ErrorOr<void> setegid(gid_t);
157ErrorOr<void> setpgid(pid_t pid, pid_t pgid);
158ErrorOr<pid_t> setsid();
159ErrorOr<pid_t> getsid(pid_t pid = 0);
160ErrorOr<void> drop_privileges();
161ErrorOr<bool> isatty(int fd);
162ErrorOr<void> link(StringView old_path, StringView new_path);
163ErrorOr<void> symlink(StringView target, StringView link_path);
164ErrorOr<void> mkdir(StringView path, mode_t);
165ErrorOr<void> chdir(StringView path);
166ErrorOr<void> rmdir(StringView path);
167ErrorOr<pid_t> fork();
168ErrorOr<int> mkstemp(Span<char> pattern);
169ErrorOr<void> fchmod(int fd, mode_t mode);
170ErrorOr<void> fchown(int fd, uid_t, gid_t);
171ErrorOr<void> rename(StringView old_path, StringView new_path);
172ErrorOr<void> unlink(StringView path);
173ErrorOr<void> utime(StringView path, Optional<struct utimbuf>);
174ErrorOr<struct utsname> uname();
175ErrorOr<Array<int, 2>> pipe2(int flags);
176#ifndef AK_OS_ANDROID
177ErrorOr<void> adjtime(const struct timeval* delta, struct timeval* old_delta);
178#endif
179enum class SearchInPath {
180 No,
181 Yes,
182};
183
184#ifdef AK_OS_SERENITY
185ErrorOr<void> exec_command(Vector<StringView>& command, bool preserve_env);
186#endif
187
188ErrorOr<void> exec(StringView filename, ReadonlySpan<StringView> arguments, SearchInPath, Optional<ReadonlySpan<StringView>> environment = {});
189
190#ifdef AK_OS_SERENITY
191ErrorOr<void> join_jail(u64 jail_index);
192ErrorOr<u64> create_jail(StringView jail_name);
193#endif
194
195ErrorOr<int> socket(int domain, int type, int protocol);
196ErrorOr<void> bind(int sockfd, struct sockaddr const*, socklen_t);
197ErrorOr<void> listen(int sockfd, int backlog);
198ErrorOr<int> accept(int sockfd, struct sockaddr*, socklen_t*);
199ErrorOr<void> connect(int sockfd, struct sockaddr const*, socklen_t);
200ErrorOr<void> shutdown(int sockfd, int how);
201ErrorOr<ssize_t> send(int sockfd, void const*, size_t, int flags);
202ErrorOr<ssize_t> sendmsg(int sockfd, const struct msghdr*, int flags);
203ErrorOr<ssize_t> sendto(int sockfd, void const*, size_t, int flags, struct sockaddr const*, socklen_t);
204ErrorOr<ssize_t> recv(int sockfd, void*, size_t, int flags);
205ErrorOr<ssize_t> recvmsg(int sockfd, struct msghdr*, int flags);
206ErrorOr<ssize_t> recvfrom(int sockfd, void*, size_t, int flags, struct sockaddr*, socklen_t*);
207ErrorOr<void> getsockopt(int sockfd, int level, int option, void* value, socklen_t* value_size);
208ErrorOr<void> setsockopt(int sockfd, int level, int option, void const* value, socklen_t value_size);
209ErrorOr<void> getsockname(int sockfd, struct sockaddr*, socklen_t*);
210ErrorOr<void> getpeername(int sockfd, struct sockaddr*, socklen_t*);
211ErrorOr<void> socketpair(int domain, int type, int protocol, int sv[2]);
212ErrorOr<Vector<gid_t>> getgroups();
213ErrorOr<void> setgroups(ReadonlySpan<gid_t>);
214ErrorOr<void> mknod(StringView pathname, mode_t mode, dev_t dev);
215ErrorOr<void> mkfifo(StringView pathname, mode_t mode);
216ErrorOr<void> setenv(StringView, StringView, bool);
217ErrorOr<void> putenv(StringView);
218ErrorOr<int> posix_openpt(int flags);
219ErrorOr<void> grantpt(int fildes);
220ErrorOr<void> unlockpt(int fildes);
221ErrorOr<void> access(StringView pathname, int mode);
222ErrorOr<DeprecatedString> readlink(StringView pathname);
223ErrorOr<int> poll(Span<struct pollfd>, int timeout);
224
225class AddressInfoVector {
226 AK_MAKE_NONCOPYABLE(AddressInfoVector);
227
228public:
229 AddressInfoVector(AddressInfoVector&&) = default;
230 ~AddressInfoVector() = default;
231
232 ReadonlySpan<struct addrinfo> addresses() const { return m_addresses; }
233
234private:
235 friend ErrorOr<AddressInfoVector> getaddrinfo(char const* nodename, char const* servname, struct addrinfo const& hints);
236
237 AddressInfoVector(Vector<struct addrinfo>&& addresses, struct addrinfo* ptr)
238 : m_addresses(move(addresses))
239 , m_ptr(adopt_own_if_nonnull(ptr))
240 {
241 }
242
243 struct AddrInfoDeleter {
244 void operator()(struct addrinfo* ptr) { ::freeaddrinfo(ptr); }
245 };
246
247 Vector<struct addrinfo> m_addresses {};
248 OwnPtr<struct addrinfo, AddrInfoDeleter> m_ptr {};
249};
250
251ErrorOr<AddressInfoVector> getaddrinfo(char const* nodename, char const* servname, struct addrinfo const& hints);
252
253#ifdef AK_OS_SERENITY
254ErrorOr<void> posix_fallocate(int fd, off_t offset, off_t length);
255#endif
256
257}