mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

samples/landlock: Format with clang-format 

commit 81709f3dcc upstream.

Let's follow a consistent and documented coding style.  Everything may
not be to our liking but it is better than tacit knowledge.  Moreover,
this will help maintain style consistency between different developers.

This contains only whitespace changes.

Automatically formatted with:
clang-format-14 -i samples/landlock/*.[ch]

Link: https://lore.kernel.org/r/20220506160513.523257-8-mic@digikod.net
Cc: stable@vger.kernel.org
Signed-off-by: Mickaël Salaün <mic@digikod.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Mickaël Salaün 2022-05-06 18:05:13 +02:00 committed by Greg Kroah-Hartman
parent 0ab7716548
commit 403c2050c8
1 changed files with 52 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
samples/landlock/sandboxer.c
View File

@ -22,9 +22,9 @@
#include <unistd.h> #include <unistd.h>
#ifndef landlock_create_ruleset #ifndef landlock_create_ruleset
static inline int landlock_create_ruleset( static inline int
const struct landlock_ruleset_attr *const attr, landlock_create_ruleset(const struct landlock_ruleset_attr *const attr,
const size_t size, const __u32 flags) const size_t size, const __u32 flags)
{ {
return syscall(__NR_landlock_create_ruleset, attr, size, flags); return syscall(__NR_landlock_create_ruleset, attr, size, flags);
} }
@ -32,17 +32,18 @@ static inline int landlock_create_ruleset(
#ifndef landlock_add_rule #ifndef landlock_add_rule
static inline int landlock_add_rule(const int ruleset_fd, static inline int landlock_add_rule(const int ruleset_fd,
const enum landlock_rule_type rule_type, const enum landlock_rule_type rule_type,
const void *const rule_attr, const __u32 flags) const void *const rule_attr,
const __u32 flags)
{ {
return syscall(__NR_landlock_add_rule, ruleset_fd, rule_type, return syscall(__NR_landlock_add_rule, ruleset_fd, rule_type, rule_attr,
rule_attr, flags); flags);
} }
#endif #endif
#ifndef landlock_restrict_self #ifndef landlock_restrict_self
static inline int landlock_restrict_self(const int ruleset_fd, static inline int landlock_restrict_self(const int ruleset_fd,
const __u32 flags) const __u32 flags)
{ {
return syscall(__NR_landlock_restrict_self, ruleset_fd, flags); return syscall(__NR_landlock_restrict_self, ruleset_fd, flags);
} }
@ -79,9 +80,8 @@ static int parse_path(char *env_path, const char ***const path_list)
/* clang-format on */ /* clang-format on */
static int populate_ruleset( static int populate_ruleset(const char *const env_var, const int ruleset_fd,
const char *const env_var, const int ruleset_fd, const __u64 allowed_access)
const __u64 allowed_access)
{ {
int num_paths, i, ret = 1; int num_paths, i, ret = 1;
char *env_path_name; char *env_path_name;
@ -111,12 +111,10 @@ static int populate_ruleset(
for (i = 0; i < num_paths; i++) { for (i = 0; i < num_paths; i++) {
struct stat statbuf; struct stat statbuf;
path_beneath.parent_fd = open(path_list[i], O_PATH | path_beneath.parent_fd = open(path_list[i], O_PATH | O_CLOEXEC);
O_CLOEXEC);
if (path_beneath.parent_fd < 0) { if (path_beneath.parent_fd < 0) {
fprintf(stderr, "Failed to open \"%s\": %s\n", fprintf(stderr, "Failed to open \"%s\": %s\n",
path_list[i], path_list[i], strerror(errno));
strerror(errno));
goto out_free_name; goto out_free_name;
} }
if (fstat(path_beneath.parent_fd, &statbuf)) { if (fstat(path_beneath.parent_fd, &statbuf)) {
@ -127,9 +125,10 @@ static int populate_ruleset(
if (!S_ISDIR(statbuf.st_mode)) if (!S_ISDIR(statbuf.st_mode))
path_beneath.allowed_access &= ACCESS_FILE; path_beneath.allowed_access &= ACCESS_FILE;
if (landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH, if (landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
&path_beneath, 0)) { &path_beneath, 0)) {
fprintf(stderr, "Failed to update the ruleset with \"%s\": %s\n", fprintf(stderr,
path_list[i], strerror(errno)); "Failed to update the ruleset with \"%s\": %s\n",
path_list[i], strerror(errno));
close(path_beneath.parent_fd); close(path_beneath.parent_fd);
goto out_free_name; goto out_free_name;
} }
@ -171,55 +170,64 @@ int main(const int argc, char *const argv[], char *const *const envp)
int ruleset_fd; int ruleset_fd;
struct landlock_ruleset_attr ruleset_attr = { struct landlock_ruleset_attr ruleset_attr = {
.handled_access_fs = ACCESS_FS_ROUGHLY_READ | .handled_access_fs = ACCESS_FS_ROUGHLY_READ |
ACCESS_FS_ROUGHLY_WRITE, ACCESS_FS_ROUGHLY_WRITE,
}; };
if (argc < 2) { if (argc < 2) {
fprintf(stderr, "usage: %s=\"...\" %s=\"...\" %s <cmd> [args]...\n\n", fprintf(stderr,
ENV_FS_RO_NAME, ENV_FS_RW_NAME, argv[0]); "usage: %s=\"...\" %s=\"...\" %s <cmd> [args]...\n\n",
fprintf(stderr, "Launch a command in a restricted environment.\n\n"); ENV_FS_RO_NAME, ENV_FS_RW_NAME, argv[0]);
fprintf(stderr,
"Launch a command in a restricted environment.\n\n");
fprintf(stderr, "Environment variables containing paths, " fprintf(stderr, "Environment variables containing paths, "
"each separated by a colon:\n"); "each separated by a colon:\n");
fprintf(stderr, "* %s: list of paths allowed to be used in a read-only way.\n", fprintf(stderr,
ENV_FS_RO_NAME); "* %s: list of paths allowed to be used in a read-only way.\n",
fprintf(stderr, "* %s: list of paths allowed to be used in a read-write way.\n", ENV_FS_RO_NAME);
ENV_FS_RW_NAME); fprintf(stderr,
fprintf(stderr, "\nexample:\n" "* %s: list of paths allowed to be used in a read-write way.\n",
"%s=\"/bin:/lib:/usr:/proc:/etc:/dev/urandom\" " ENV_FS_RW_NAME);
"%s=\"/dev/null:/dev/full:/dev/zero:/dev/pts:/tmp\" " fprintf(stderr,
"%s bash -i\n", "\nexample:\n"
ENV_FS_RO_NAME, ENV_FS_RW_NAME, argv[0]); "%s=\"/bin:/lib:/usr:/proc:/etc:/dev/urandom\" "
"%s=\"/dev/null:/dev/full:/dev/zero:/dev/pts:/tmp\" "
"%s bash -i\n",
ENV_FS_RO_NAME, ENV_FS_RW_NAME, argv[0]);
return 1; return 1;
} }
ruleset_fd = landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0); ruleset_fd =
landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0);
if (ruleset_fd < 0) { if (ruleset_fd < 0) {
const int err = errno; const int err = errno;
perror("Failed to create a ruleset"); perror("Failed to create a ruleset");
switch (err) { switch (err) {
case ENOSYS: case ENOSYS:
fprintf(stderr, "Hint: Landlock is not supported by the current kernel. " fprintf(stderr,
"To support it, build the kernel with " "Hint: Landlock is not supported by the current kernel. "
"CONFIG_SECURITY_LANDLOCK=y and prepend " "To support it, build the kernel with "
"\"landlock,\" to the content of CONFIG_LSM.\n"); "CONFIG_SECURITY_LANDLOCK=y and prepend "
"\"landlock,\" to the content of CONFIG_LSM.\n");
break; break;
case EOPNOTSUPP: case EOPNOTSUPP:
fprintf(stderr, "Hint: Landlock is currently disabled. " fprintf(stderr,
"It can be enabled in the kernel configuration by " "Hint: Landlock is currently disabled. "
"prepending \"landlock,\" to the content of CONFIG_LSM, " "It can be enabled in the kernel configuration by "
"or at boot time by setting the same content to the " "prepending \"landlock,\" to the content of CONFIG_LSM, "
"\"lsm\" kernel parameter.\n"); "or at boot time by setting the same content to the "
"\"lsm\" kernel parameter.\n");
break; break;
} }
return 1; return 1;
} }
if (populate_ruleset(ENV_FS_RO_NAME, ruleset_fd, if (populate_ruleset(ENV_FS_RO_NAME, ruleset_fd,
ACCESS_FS_ROUGHLY_READ)) { ACCESS_FS_ROUGHLY_READ)) {
goto err_close_ruleset; goto err_close_ruleset;
} }
if (populate_ruleset(ENV_FS_RW_NAME, ruleset_fd, if (populate_ruleset(ENV_FS_RW_NAME, ruleset_fd,
ACCESS_FS_ROUGHLY_READ | ACCESS_FS_ROUGHLY_WRITE)) { ACCESS_FS_ROUGHLY_READ |
ACCESS_FS_ROUGHLY_WRITE)) {
goto err_close_ruleset; goto err_close_ruleset;
} }
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) { if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {
@ -236,7 +244,7 @@ int main(const int argc, char *const argv[], char *const *const envp)
cmd_argv = argv + 1; cmd_argv = argv + 1;
execvpe(cmd_path, cmd_argv, envp); execvpe(cmd_path, cmd_argv, envp);
fprintf(stderr, "Failed to execute \"%s\": %s\n", cmd_path, fprintf(stderr, "Failed to execute \"%s\": %s\n", cmd_path,
strerror(errno)); strerror(errno));
fprintf(stderr, "Hint: access to the binary, the interpreter or " fprintf(stderr, "Hint: access to the binary, the interpreter or "
"shared libraries may be denied.\n"); "shared libraries may be denied.\n");
return 1; return 1;