jail: Create its own type

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/pakfire/archive.c b/src/pakfire/archive.c
index 39637e0b67fe99df27832b9eabef090f317c759d..1ea177adaec8689f40ad4eeafedbd8b9d4bc2681 100644 (file)
--- a/src/pakfire/archive.c
+++ b/src/pakfire/archive.c
@@ -1938,7 +1938,7 @@ static ssize_t pakfire_archive_stream_payload(
 
 static int pakfire_archive_handle_systemd_sysusers(pakfire_archive* archive,
                struct archive* a, struct archive_entry* e, void* data) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        char replace[PATH_MAX];
        int r;
 

diff --git a/src/pakfire/build.c b/src/pakfire/build.c
index 1da44023c9523cc9c94784096026964ba3d496d3..d19ba7a8c6881af8ff28348522d863f33780dc20 100644 (file)
--- a/src/pakfire/build.c
+++ b/src/pakfire/build.c
@@ -85,7 +85,7 @@ struct pakfire_build {
        pakfire_cgroup* cgroup;
 
        // Jail
-       struct pakfire_jail* jail;
+       pakfire_jail* jail;
 
        // Environment
        pakfire_env* env;
@@ -297,7 +297,7 @@ static int pakfire_build_run_script(
        }
 
        // Execute the script
-       r = pakfire_jail_exec_script(build->jail, script, length, args, build->env,
+       r = pakfire_jail_execute_script(build->jail, script, length, args, build->env,
                        input_callback, input_data, output_callback, output_data);
        if (r)
                ERROR(build->ctx, "Script '%s' failed with status %d\n", filename, r);
@@ -819,7 +819,7 @@ static int pakfire_build_find_perl_deps(pakfire_build* build,
        if (r < 0)
                goto ERROR;
 
-       struct pakfire_jail_filelist input = {
+       pakfire_jail_filelist input = {
                .filelist = perlfiles,
        };
 
@@ -1413,7 +1413,7 @@ static int pakfire_build_stage(pakfire_build* build,
        INFO(build->ctx, "Running build stage '%s'\n", stage);
 
        // Run the script
-       r = pakfire_jail_exec_script(build->jail, script, strlen(script), NULL, env,
+       r = pakfire_jail_execute_script(build->jail, script, strlen(script), NULL, env,
                        NULL, NULL, pakfire_build_output_callback, build);
        switch (r) {
                case 130:
@@ -2865,7 +2865,7 @@ int pakfire_build_shell(pakfire_build* build, const char* argv[], const char** p
 
        // Run the command (if given)
        if (argv)
-               return pakfire_jail_exec_command(build->jail, argv, build->env, 0);
+               return pakfire_jail_execute_command(build->jail, argv, build->env, 0);
 
        // Otherwise run the shell
        return pakfire_jail_shell(build->jail, build->env);

diff --git a/src/pakfire/jail.c b/src/pakfire/jail.c
index 8330190eb6e3e06a936b13fab2ace7580456e14d..17df871779d6984af09158e4244ab03ea98c1844 100644 (file)
--- a/src/pakfire/jail.c
+++ b/src/pakfire/jail.c
@@ -83,11 +83,11 @@ static const struct environ {
        { NULL, NULL },
 };
 
-struct pakfire_jail_mountpoint {
+typedef struct pakfire_jail_mountpoint {
        char source[PATH_MAX];
        char target[PATH_MAX];
        int flags;
-};
+} pakfire_jail_mountpoint;
 
 struct pakfire_jail {
        pakfire_ctx* ctx;
@@ -111,12 +111,12 @@ struct pakfire_jail {
        pakfire_env* env;
 
        // Mountpoints
-       struct pakfire_jail_mountpoint mountpoints[MAX_MOUNTPOINTS];
+       pakfire_jail_mountpoint mountpoints[MAX_MOUNTPOINTS];
        unsigned int num_mountpoints;
 };
 
-struct pakfire_jail_exec {
-       struct pakfire_jail* jail;
+typedef struct pakfire_jail_exec {
+       pakfire_jail* jail;
 
        sd_event* loop;
        int flags;
@@ -177,14 +177,14 @@ struct pakfire_jail_exec {
                pakfire_jail_output_callback output;
                void* output_data;
        } callbacks;
-};
+} pakfire_jail_exec;
 
 static int pakfire_jail_exec_has_flag(
-               const struct pakfire_jail_exec* ctx, const enum pakfire_jail_exec_flags flag) {
+               const pakfire_jail_exec* ctx, const enum pakfire_jail_exec_flags flag) {
        return ctx->flags & flag;
 }
 
-static void pakfire_jail_free(struct pakfire_jail* jail) {
+static void pakfire_jail_free(pakfire_jail* jail) {
        if (jail->cgroup)
                pakfire_cgroup_unref(jail->cgroup);
        if (jail->pakfire)
@@ -196,15 +196,15 @@ static void pakfire_jail_free(struct pakfire_jail* jail) {
        free(jail);
 }
 
-static const char* pakfire_jail_uuid(struct pakfire_jail* jail) {
+static const char* pakfire_jail_uuid(pakfire_jail* jail) {
        if (!*jail->__uuid)
                uuid_unparse_lower(jail->uuid, jail->__uuid);
 
        return jail->__uuid;
 }
 
-int pakfire_jail_create(struct pakfire_jail** jail, struct pakfire* pakfire) {
-       struct pakfire_jail* self = NULL;
+int pakfire_jail_create(pakfire_jail** jail, struct pakfire* pakfire) {
+       pakfire_jail* self = NULL;
        int r;
 
        // Allocate a new jail
@@ -271,13 +271,13 @@ ERROR:
        return r;
 }
 
-struct pakfire_jail* pakfire_jail_ref(struct pakfire_jail* jail) {
+pakfire_jail* pakfire_jail_ref(pakfire_jail* jail) {
        ++jail->nrefs;
 
        return jail;
 }
 
-struct pakfire_jail* pakfire_jail_unref(struct pakfire_jail* jail) {
+pakfire_jail* pakfire_jail_unref(pakfire_jail* jail) {
        if (--jail->nrefs > 0)
                return jail;
 
@@ -287,7 +287,7 @@ struct pakfire_jail* pakfire_jail_unref(struct pakfire_jail* jail) {
 
 // Resource Limits
 
-int pakfire_jail_nice(struct pakfire_jail* jail, int nice) {
+int pakfire_jail_nice(pakfire_jail* jail, int nice) {
        // Check if nice level is in range
        if (nice < -19 || nice > 20)
                return -EINVAL;
@@ -298,7 +298,7 @@ int pakfire_jail_nice(struct pakfire_jail* jail, int nice) {
        return 0;
 }
 
-int pakfire_jail_set_cgroup(struct pakfire_jail* jail, pakfire_cgroup* cgroup) {
+int pakfire_jail_set_cgroup(pakfire_jail* jail, pakfire_cgroup* cgroup) {
        // Free any previous cgroup
        if (jail->cgroup) {
                pakfire_cgroup_unref(jail->cgroup);
@@ -323,7 +323,7 @@ int pakfire_jail_set_cgroup(struct pakfire_jail* jail, pakfire_cgroup* cgroup) {
 // Timeout
 
 int pakfire_jail_set_timeout(
-               struct pakfire_jail* jail, unsigned int timeout) {
+               pakfire_jail* jail, unsigned int timeout) {
        // Store value
        jail->timeout = timeout;
 
@@ -339,7 +339,7 @@ int pakfire_jail_set_timeout(
        Pipes
 */
 
-static int pakfire_jail_setup_pipe(struct pakfire_jail* self, int (*fds)[2], const int flags) {
+static int pakfire_jail_setup_pipe(pakfire_jail* self, int (*fds)[2], const int flags) {
        int r;
 
        // Setup the pipe
@@ -352,7 +352,7 @@ static int pakfire_jail_setup_pipe(struct pakfire_jail* self, int (*fds)[2], con
        return 0;
 }
 
-static void pakfire_jail_close_pipe(struct pakfire_jail* self, int fds[2]) {
+static void pakfire_jail_close_pipe(pakfire_jail* self, int fds[2]) {
        for (unsigned int i = 0; i < 2; i++)
                if (fds[i] >= 0)
                        close(fds[i]);
@@ -362,7 +362,7 @@ static void pakfire_jail_close_pipe(struct pakfire_jail* self, int fds[2]) {
        This is a convenience function to fetch the reading end of a pipe and
        closes the write end.
 */
-static int pakfire_jail_get_pipe_to_read(struct pakfire_jail* self, int (*fds)[2]) {
+static int pakfire_jail_get_pipe_to_read(pakfire_jail* self, int (*fds)[2]) {
        // Give the variables easier names to avoid confusion
        int* fd_read  = &(*fds)[0];
        int* fd_write = &(*fds)[1];
@@ -380,7 +380,7 @@ static int pakfire_jail_get_pipe_to_read(struct pakfire_jail* self, int (*fds)[2
        return -EBADF;
 }
 
-static int pakfire_jail_get_pipe_to_write(struct pakfire_jail* self, int (*fds)[2]) {
+static int pakfire_jail_get_pipe_to_write(pakfire_jail* self, int (*fds)[2]) {
        // Give the variables easier names to avoid confusion
        int* fd_read  = &(*fds)[0];
        int* fd_write = &(*fds)[1];
@@ -399,8 +399,8 @@ static int pakfire_jail_get_pipe_to_write(struct pakfire_jail* self, int (*fds)[
 }
 
 static int pakfire_jail_stdin(sd_event_source* source, int fd, unsigned int events, void* data) {
-       struct pakfire_jail_exec* exec = data;
-       struct pakfire_jail* self = exec->jail;
+       pakfire_jail_exec* exec = data;
+       pakfire_jail* self = exec->jail;
        ssize_t bytes_written = 0;
        ssize_t bytes_read = 0;
 
@@ -453,7 +453,7 @@ CLOSE:
        return 0;
 }
 
-static int pakfire_jail_output(struct pakfire_jail* self, int fd, unsigned int events, FILE* f) {
+static int pakfire_jail_output(pakfire_jail* self, int fd, unsigned int events, FILE* f) {
        ssize_t bytes_written = 0;
        ssize_t bytes_read = 0;
        char buffer[4096];
@@ -492,20 +492,20 @@ END:
 }
 
 static int pakfire_jail_stdout(sd_event_source* source, int fd, unsigned int events, void* data) {
-       struct pakfire_jail_exec* exec = data;
+       pakfire_jail_exec* exec = data;
 
        return pakfire_jail_output(exec->jail, fd, events, exec->streams.stdout);
 }
 
 static int pakfire_jail_stderr(sd_event_source* source, int fd, unsigned int events, void* data) {
-       struct pakfire_jail_exec* exec = data;
+       pakfire_jail_exec* exec = data;
 
        return pakfire_jail_output(exec->jail, fd, events, exec->streams.stderr);
 }
 
 static int pakfire_jail_drain(sd_event_source* source, void* data) {
-       struct pakfire_jail_exec* exec = data;
-       struct pakfire_jail* self = exec->jail;
+       pakfire_jail_exec* exec = data;
+       pakfire_jail* self = exec->jail;
        int r;
 
        DEBUG(self->ctx, "Draining the pipes...\n");
@@ -538,7 +538,7 @@ static void pakfire_jail_log_redirect(void* data, int priority, const char* file
 
 static void pakfire_jail_log_redirect(void* data, int priority, const char* file,
                int line, const char* fn, const char* format, va_list args) {
-       struct pakfire_jail_exec* ctx = data;
+       pakfire_jail_exec* ctx = data;
 
        switch (priority) {
                case LOG_INFO:
@@ -569,21 +569,21 @@ static void pakfire_jail_log_redirect(void* data, int priority, const char* file
        Passes any log messages on to the context logger
 */
 static int pakfire_jail_INFO(pakfire_ctx* ctx, void* data, const char* line, size_t length) {
-       struct pakfire_jail* jail = data;
+       pakfire_jail* jail = data;
 
        INFO(jail->ctx, "%.*s", (int)length, line);
        return 0;
 }
 
 static int pakfire_jail_WARN(pakfire_ctx* ctx, void* data, const char* line, size_t length) {
-       struct pakfire_jail* jail = data;
+       pakfire_jail* jail = data;
 
        ERROR(jail->ctx, "%.*s", (int)length, line);
        return 0;
 }
 
 static int pakfire_jail_ERROR(pakfire_ctx* ctx, void* data, const char* line, size_t length) {
-       struct pakfire_jail* jail = data;
+       pakfire_jail* jail = data;
 
        ERROR(jail->ctx, "%.*s", (int)length, line);
        return 0;
@@ -591,7 +591,7 @@ static int pakfire_jail_ERROR(pakfire_ctx* ctx, void* data, const char* line, si
 
 #ifdef ENABLE_DEBUG
 static int pakfire_jail_DEBUG(pakfire_ctx* ctx, void* data, const char* line, size_t length) {
-       struct pakfire_jail* jail = data;
+       pakfire_jail* jail = data;
 
        DEBUG(jail->ctx, "%.*s", (int)length, line);
        return 0;
@@ -599,7 +599,7 @@ static int pakfire_jail_DEBUG(pakfire_ctx* ctx, void* data, const char* line, si
 #endif /* ENABLE_DEBUG */
 
 static int pakfire_jail_output_stdout(pakfire_ctx* ctx, void* data, const char* line, size_t length) {
-       struct pakfire_jail_exec* exec = data;
+       pakfire_jail_exec* exec = data;
 
        // Do nothing if we don't have a callback
        if (!exec->callbacks.output)
@@ -609,7 +609,7 @@ static int pakfire_jail_output_stdout(pakfire_ctx* ctx, void* data, const char*
 }
 
 static int pakfire_jail_output_stderr(pakfire_ctx* ctx, void* data, const char* line, size_t length) {
-       struct pakfire_jail_exec* exec = data;
+       pakfire_jail_exec* exec = data;
 
        // Do nothing if we don't have a callback
        if (!exec->callbacks.output)
@@ -621,7 +621,7 @@ static int pakfire_jail_output_stderr(pakfire_ctx* ctx, void* data, const char*
 // Capabilities
 
 // Logs all capabilities of the current process
-static int pakfire_jail_show_capabilities(struct pakfire_jail* jail) {
+static int pakfire_jail_show_capabilities(pakfire_jail* jail) {
        cap_t caps = NULL;
        char* name = NULL;
        cap_flag_value_t value_e;
@@ -686,7 +686,7 @@ ERROR:
        return r;
 }
 
-static int pakfire_jail_set_capabilities(struct pakfire_jail* jail) {
+static int pakfire_jail_set_capabilities(pakfire_jail* jail) {
        cap_t caps = NULL;
        char* name = NULL;
        int r;
@@ -766,7 +766,7 @@ ERROR:
 
 // Syscall Filter
 
-static int pakfire_jail_limit_syscalls(struct pakfire_jail* jail) {
+static int pakfire_jail_limit_syscalls(pakfire_jail* jail) {
        const int syscalls[] = {
                // The kernel's keyring isn't namespaced
                SCMP_SYS(keyctl),
@@ -817,9 +817,9 @@ ERROR:
 
 // Mountpoints
 
-int pakfire_jail_bind(struct pakfire_jail* self,
+int pakfire_jail_bind(pakfire_jail* self,
                const char* source, const char* target, int flags) {
-       struct pakfire_jail_mountpoint* mp = NULL;
+       pakfire_jail_mountpoint* mp = NULL;
        int r;
 
        // Check if there is any space left
@@ -856,7 +856,7 @@ int pakfire_jail_bind(struct pakfire_jail* self,
        return 0;
 }
 
-static int pakfire_jail_mount_networking(struct pakfire_jail* jail) {
+static int pakfire_jail_mount_networking(pakfire_jail* jail) {
        int r;
 
        const char* paths[] = {
@@ -887,8 +887,8 @@ static int pakfire_jail_mount_networking(struct pakfire_jail* jail) {
 /*
        Mounts everything that we require in the new namespace
 */
-static int pakfire_jail_mount(struct pakfire_jail* jail, struct pakfire_jail_exec* ctx) {
-       struct pakfire_jail_mountpoint* mp = NULL;
+static int pakfire_jail_mount(pakfire_jail* jail, pakfire_jail_exec* ctx) {
+       pakfire_jail_mountpoint* mp = NULL;
        int flags = 0;
        int r;
 
@@ -934,7 +934,7 @@ static int pakfire_jail_mount(struct pakfire_jail* jail, struct pakfire_jail_exe
 
 // Networking
 
-static int pakfire_jail_setup_loopback(struct pakfire_jail* jail) {
+static int pakfire_jail_setup_loopback(pakfire_jail* jail) {
        struct nl_sock* nl = NULL;
        struct nl_cache* cache = NULL;
        struct rtnl_link* link = NULL;
@@ -1003,7 +1003,7 @@ ERROR:
 
 // UID/GID Mapping
 
-static int pakfire_jail_setup_uid_mapping(struct pakfire_jail* jail, pid_t pid) {
+static int pakfire_jail_setup_uid_mapping(pakfire_jail* jail, pid_t pid) {
        char path[PATH_MAX];
        int r;
 
@@ -1043,7 +1043,7 @@ static int pakfire_jail_setup_uid_mapping(struct pakfire_jail* jail, pid_t pid)
        return r;
 }
 
-static int pakfire_jail_setup_gid_mapping(struct pakfire_jail* jail, pid_t pid) {
+static int pakfire_jail_setup_gid_mapping(pakfire_jail* jail, pid_t pid) {
        char path[PATH_MAX];
        int r;
 
@@ -1077,7 +1077,7 @@ static int pakfire_jail_setup_gid_mapping(struct pakfire_jail* jail, pid_t pid)
        return r;
 }
 
-static int pakfire_jail_setgroups(struct pakfire_jail* jail, pid_t pid) {
+static int pakfire_jail_setgroups(pakfire_jail* jail, pid_t pid) {
        char path[PATH_MAX];
        int r;
 
@@ -1095,7 +1095,7 @@ static int pakfire_jail_setgroups(struct pakfire_jail* jail, pid_t pid) {
        return r;
 }
 
-static int pakfire_jail_send_signal(struct pakfire_jail* jail, int fd) {
+static int pakfire_jail_send_signal(pakfire_jail* jail, int fd) {
        const uint64_t val = 1;
        int r = 0;
 
@@ -1114,7 +1114,7 @@ static int pakfire_jail_send_signal(struct pakfire_jail* jail, int fd) {
        return r;
 }
 
-static int pakfire_jail_wait_for_signal(struct pakfire_jail* jail, int fd) {
+static int pakfire_jail_wait_for_signal(pakfire_jail* jail, int fd) {
        uint64_t val = 0;
        int r = 0;
 
@@ -1143,8 +1143,8 @@ static int pakfire_jail_SIGCHLD(
 */
 static int pakfire_jail_terminate(sd_event_source* source,
                const struct signalfd_siginfo* si, void* data) {
-       struct pakfire_jail_exec* exec = data;
-       struct pakfire_jail* self = exec->jail;
+       pakfire_jail_exec* exec = data;
+       pakfire_jail* self = exec->jail;
        int r;
 
        // Log action
@@ -1168,8 +1168,8 @@ static int pakfire_jail_terminate(sd_event_source* source,
        Called when the timer has expired.
 */
 static int pakfire_jail_timer(sd_event_source* s, uint64_t usec, void* data) {
-       struct pakfire_jail_exec* ctx = data;
-       struct pakfire_jail* jail = ctx->jail;
+       pakfire_jail_exec* ctx = data;
+       pakfire_jail* jail = ctx->jail;
        int r;
 
        DEBUG(jail->ctx, "Timer has fired...\n");
@@ -1186,8 +1186,8 @@ static int pakfire_jail_timer(sd_event_source* s, uint64_t usec, void* data) {
        Called when the child process has exited.
 */
 static int pakfire_jail_exited(sd_event_source* source, const siginfo_t* si, void* data) {
-       struct pakfire_jail_exec* ctx = data;
-       struct pakfire_jail* jail = ctx->jail;
+       pakfire_jail_exec* ctx = data;
+       pakfire_jail* jail = ctx->jail;
        int r = 0;
 
        switch (si->si_code) {
@@ -1218,14 +1218,14 @@ static int pakfire_jail_exited(sd_event_source* source, const siginfo_t* si, voi
        return sd_event_exit(ctx->loop, r);
 }
 
-struct pakfire_jail_command {
-       struct pakfire_jail* jail;
+typedef struct pakfire_jail_command {
+       pakfire_jail* jail;
        const char** argv;
        pakfire_env* env;
-};
+} pakfire_jail_command;
 
 static int pakfire_jail_launch_command(pakfire_ctx* ctx, void* data) {
-       struct pakfire_jail_command* command = data;
+       pakfire_jail_command* command = data;
        pakfire_env* env = NULL;
        char** envp = NULL;
        int r;
@@ -1294,7 +1294,7 @@ ERROR:
 /*
        Performs the initialisation that needs to happen in the parent part
 */
-static int pakfire_jail_parent(struct pakfire_jail* jail, struct pakfire_jail_exec* ctx) {
+static int pakfire_jail_parent(pakfire_jail* jail, pakfire_jail_exec* ctx) {
        int fd = -EBADF;
        int r;
 
@@ -1398,7 +1398,7 @@ static int pakfire_jail_parent(struct pakfire_jail* jail, struct pakfire_jail_ex
        return 0;
 }
 
-static int pakfire_jail_switch_root(struct pakfire_jail* jail, const char* root) {
+static int pakfire_jail_switch_root(pakfire_jail* jail, const char* root) {
        int r;
 
        // Change to the new root
@@ -1425,7 +1425,7 @@ static int pakfire_jail_switch_root(struct pakfire_jail* jail, const char* root)
        return 0;
 }
 
-static int pakfire_jail_connect_null(struct pakfire_jail* self, int fileno) {
+static int pakfire_jail_connect_null(pakfire_jail* self, int fileno) {
        int fd = -EBADF;
        int flags = 0;
        int r;
@@ -1468,7 +1468,7 @@ ERROR:
        return r;
 }
 
-static int pakfire_jail_child(struct pakfire_jail* jail, struct pakfire_jail_exec* ctx) {
+static int pakfire_jail_child(pakfire_jail* jail, pakfire_jail_exec* ctx) {
        int r;
 
        // Redirect any logging to our log pipe
@@ -1716,7 +1716,7 @@ static int pakfire_jail_child(struct pakfire_jail* jail, struct pakfire_jail_exe
 }
 
 // Run a command in the jail
-static int __pakfire_jail_exec(struct pakfire_jail* jail,
+static int __pakfire_jail_exec(pakfire_jail* jail,
                pakfire_jail_main_callback callback, void* data, int flags,
                pakfire_jail_input_callback input_callback, void* input_data,
                pakfire_jail_output_callback output_callback, void* output_data,
@@ -1730,7 +1730,7 @@ static int __pakfire_jail_exec(struct pakfire_jail* jail,
                return -EINVAL;
 
        // Initialize context for this call
-       struct pakfire_jail_exec ctx = {
+       pakfire_jail_exec ctx = {
                .jail  = jail,
                .flags = flags,
                .pidfd = -EBADF,
@@ -2038,14 +2038,14 @@ ERROR:
        return r;
 }
 
-int pakfire_jail_exec(struct pakfire_jail* jail,
+int pakfire_jail_execute(pakfire_jail* jail,
                pakfire_jail_main_callback callback, void* data, int flags) {
        return __pakfire_jail_exec(jail, callback, data, flags, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
-int pakfire_jail_exec_command(struct pakfire_jail* jail,
+int pakfire_jail_execute_command(pakfire_jail* jail,
                const char* argv[], pakfire_env* env, int flags) {
-       struct pakfire_jail_command command = {
+       pakfire_jail_command command = {
                .jail = jail,
                .argv = argv,
                .env  = env,
@@ -2055,9 +2055,9 @@ int pakfire_jail_exec_command(struct pakfire_jail* jail,
                NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
-int pakfire_jail_exec_capture_output(struct pakfire_jail* jail,
+int pakfire_jail_execute_capture_output(pakfire_jail* jail,
                const char* argv[], pakfire_env* env, int flags, char** output, size_t* length) {
-       struct pakfire_jail_command command = {
+       pakfire_jail_command command = {
                .jail = jail,
                .argv = argv,
                .env  = env,
@@ -2068,10 +2068,10 @@ int pakfire_jail_exec_capture_output(struct pakfire_jail* jail,
 }
 
 int pakfire_jail_communicate(
-               struct pakfire_jail* jail, const char* argv[], pakfire_env* env, int flags,
+               pakfire_jail* jail, const char* argv[], pakfire_env* env, int flags,
                pakfire_jail_input_callback input_callback, void* input_data,
                pakfire_jail_output_callback output_callback, void* output_data) {
-       struct pakfire_jail_command command = {
+       pakfire_jail_command command = {
                .jail = jail,
                .argv = argv,
                .env  = env,
@@ -2081,7 +2081,7 @@ int pakfire_jail_communicate(
                input_callback, input_data, output_callback, output_data, NULL, NULL);
 }
 
-int pakfire_jail_exec_script(struct pakfire_jail* jail,
+int pakfire_jail_execute_script(pakfire_jail* jail,
                const char* script, const size_t size, const char* args[], pakfire_env* env,
                pakfire_jail_input_callback input_callback, void* input_data,
                pakfire_jail_output_callback output_callback, void* output_data) {
@@ -2165,7 +2165,7 @@ ERROR:
 */
 int pakfire_jail_run(struct pakfire* pakfire, const char* argv[], pakfire_env* env,
                int flags, char** output, size_t* output_length) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r;
 
        // Create a new jail
@@ -2174,7 +2174,7 @@ int pakfire_jail_run(struct pakfire* pakfire, const char* argv[], pakfire_env* e
                goto ERROR;
 
        // Execute the command
-       r = pakfire_jail_exec_capture_output(jail, argv, env, flags, output, output_length);
+       r = pakfire_jail_execute_capture_output(jail, argv, env, flags, output, output_length);
 
 ERROR:
        if (jail)
@@ -2185,7 +2185,7 @@ ERROR:
 
 int pakfire_jail_run_script(struct pakfire* pakfire, const char* script, const size_t length,
                const char* argv[], pakfire_env* env, int flags) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r;
 
        // Create a new jail
@@ -2194,7 +2194,7 @@ int pakfire_jail_run_script(struct pakfire* pakfire, const char* script, const s
                goto ERROR;
 
        // Execute the command
-       r = pakfire_jail_exec_script(jail, script, length, argv, env, NULL, NULL, NULL, NULL);
+       r = pakfire_jail_execute_script(jail, script, length, argv, env, NULL, NULL, NULL, NULL);
 
 ERROR:
        if (jail)
@@ -2203,7 +2203,7 @@ ERROR:
        return r;
 }
 
-int pakfire_jail_shell(struct pakfire_jail* jail, pakfire_env* e) {
+int pakfire_jail_shell(pakfire_jail* jail, pakfire_env* e) {
        pakfire_env* env = NULL;
        int r;
 
@@ -2240,7 +2240,7 @@ int pakfire_jail_shell(struct pakfire_jail* jail, pakfire_env* e) {
        }
 
        // Execute /bin/bash
-       r = pakfire_jail_exec_command(jail, argv, env, PAKFIRE_JAIL_INTERACTIVE);
+       r = pakfire_jail_execute_command(jail, argv, env, PAKFIRE_JAIL_INTERACTIVE);
        if (r < 0)
                goto ERROR;
 
@@ -2328,7 +2328,7 @@ ssize_t pakfire_jail_send_buffer(pakfire_ctx* ctx,
 
 ssize_t pakfire_jail_send_filelist(pakfire_ctx* ctx,
                void* data, char* buffer, size_t length) {
-       struct pakfire_jail_filelist* input = data;
+       pakfire_jail_filelist* input = data;
        pakfire_file* file = NULL;
        int r;
 

diff --git a/src/pakfire/jail.h b/src/pakfire/jail.h
index fea9c3c42a70605462c59de63643b1d362b6aeec..4ad35b318dc4baf6ebacb5feccc45b5e8c0f3e23 100644 (file)
--- a/src/pakfire/jail.h
+++ b/src/pakfire/jail.h
@@ -26,7 +26,7 @@
 #include <pakfire/env.h>
 #include <pakfire/pakfire.h>
 
-struct pakfire_jail;
+typedef struct pakfire_jail pakfire_jail;
 
 // Input callback
 typedef pakfire_buffer_input_callback pakfire_jail_input_callback;
@@ -40,20 +40,20 @@ enum pakfire_jail_output_stream {
 typedef int (*pakfire_jail_output_callback)(pakfire_ctx* ctx, void* data,
        const enum pakfire_jail_output_stream stream, const char* line, size_t length);
 
-int pakfire_jail_create(struct pakfire_jail** jail, struct pakfire* pakfire);
+int pakfire_jail_create(pakfire_jail** jail, struct pakfire* pakfire);
 
-struct pakfire_jail* pakfire_jail_ref(struct pakfire_jail* jail);
-struct pakfire_jail* pakfire_jail_unref(struct pakfire_jail* jail);
+pakfire_jail* pakfire_jail_ref(pakfire_jail* jail);
+pakfire_jail* pakfire_jail_unref(pakfire_jail* jail);
 
 // Mountpoints
-int pakfire_jail_bind(struct pakfire_jail* jail,
+int pakfire_jail_bind(pakfire_jail* jail,
        const char* source, const char* target, int flags);
 
 // Resource Limits
-int pakfire_jail_nice(struct pakfire_jail* jail, int nice);
+int pakfire_jail_nice(pakfire_jail* jail, int nice);
 
 // Timeout
-int pakfire_jail_set_timeout(struct pakfire_jail* jail, unsigned int timeout);
+int pakfire_jail_set_timeout(pakfire_jail* jail, unsigned int timeout);
 
 typedef int (*pakfire_jail_main_callback)(pakfire_ctx* ctx, void* data);
 
@@ -64,20 +64,20 @@ enum pakfire_jail_exec_flags {
        PAKFIRE_JAIL_HAS_LOOP_DEVICES = (1 << 3),
 };
 
-int pakfire_jail_exec(struct pakfire_jail* jail,
+int pakfire_jail_execute(pakfire_jail* jail,
        pakfire_jail_main_callback callback, void* data, int flags);
 
-int pakfire_jail_exec_command(struct pakfire_jail* jail,
+int pakfire_jail_execute_command(pakfire_jail* jail,
        const char* argv[], pakfire_env* env, int flags);
 
-int pakfire_jail_exec_capture_output(struct pakfire_jail* jail,
+int pakfire_jail_execute_capture_output(pakfire_jail* jail,
        const char* argv[], pakfire_env* env, int flags, char** output, size_t* length);
 
 // Resource limits
-int pakfire_jail_set_cgroup(struct pakfire_jail* jail, pakfire_cgroup* cgroup);
+int pakfire_jail_set_cgroup(pakfire_jail* jail, pakfire_cgroup* cgroup);
 
 int pakfire_jail_communicate(
-       struct pakfire_jail* jail, const char* argv[], pakfire_env* env, int flags,
+       pakfire_jail* jail, const char* argv[], pakfire_env* env, int flags,
        pakfire_jail_input_callback input_callback, void* input_data,
        pakfire_jail_output_callback output_callback, void* output_data);
 
@@ -87,12 +87,12 @@ int pakfire_jail_run(struct pakfire* pakfire,
 int pakfire_jail_run_script(struct pakfire* pakfire,
        const char* script, const size_t length, const char* argv[], pakfire_env* env, int flags);
 
-int pakfire_jail_exec_script(struct pakfire_jail* jail,
+int pakfire_jail_execute_script(pakfire_jail* jail,
        const char* script, const size_t size, const char* args[], pakfire_env* env,
        pakfire_jail_input_callback input_callback, void* input_data,
        pakfire_jail_output_callback output_callback, void* output_data);
 
-int pakfire_jail_shell(struct pakfire_jail* jail, pakfire_env* env);
+int pakfire_jail_shell(pakfire_jail* jail, pakfire_env* env);
 int pakfire_jail_ldconfig(struct pakfire* pakfire);
 int pakfire_jail_run_systemd_tmpfiles(struct pakfire* pakfire);
 
@@ -107,14 +107,14 @@ ssize_t pakfire_jail_send_buffer(pakfire_ctx* ctx,
 
 // Stream a filelist
 
-struct pakfire_jail_filelist {
+typedef struct pakfire_jail_filelist {
        pakfire_filelist* filelist;
        size_t i;
 
        // Buffer for the path
        char buffer[PATH_MAX];
        const char* p;
-};
+} pakfire_jail_filelist;
 
 ssize_t pakfire_jail_send_filelist(pakfire_ctx* ctx,
        void* data, char* buffer, size_t length);

diff --git a/src/pakfire/stripper.c b/src/pakfire/stripper.c
index 2a55fa815a5d6cdc4397d4ef39d8a1cd73c8e590..06270808ec8a90c0a167673f73530587e48ca8f2 100644 (file)
--- a/src/pakfire/stripper.c
+++ b/src/pakfire/stripper.c
@@ -44,7 +44,7 @@ struct pakfire_stripper {
        struct pakfire* pakfire;
 
        // Jail
-       struct pakfire_jail* jail;
+       pakfire_jail* jail;
 
        // Path
        char path[PATH_MAX];
@@ -77,7 +77,7 @@ static int pakfire_stripper_open_sources(struct pakfire_stripper* self) {
 }
 
 int pakfire_stripper_create(struct pakfire_stripper** stripper,
-               struct pakfire* pakfire, struct pakfire_jail* jail, const char* path) {
+               struct pakfire* pakfire, pakfire_jail* jail, const char* path) {
        struct pakfire_stripper* self = NULL;
        int r;
 
@@ -383,7 +383,7 @@ static int pakfire_stripper_extract_debuginfo(struct pakfire_stripper* self,
                return r;
 
        // Run the command
-       r = pakfire_jail_exec_command(self->jail, argv, NULL, 0);
+       r = pakfire_jail_execute_command(self->jail, argv, NULL, 0);
        if (r < 0) {
                ERROR(self->ctx, "Could not extract debug sections from %s: %s\n",
                        pakfire_file_get_path(file), strerror(-r));
@@ -489,7 +489,7 @@ static int pakfire_stripper_strip_debuginfo(struct pakfire_stripper* self,
        }
 
        // Run the command
-       r = pakfire_jail_exec_command(self->jail, (const char**)argv, NULL, 0);
+       r = pakfire_jail_execute_command(self->jail, (const char**)argv, NULL, 0);
        if (r < 0) {
                ERROR(self->ctx, "Could not strip debug sections from %s: %s\n",
                        pakfire_file_get_path(file), strerror(-r));

diff --git a/src/pakfire/stripper.h b/src/pakfire/stripper.h
index e6f53eb930aa69047bd5b9ef0950eb314ebb7fea..1829c21569833a47941dbcf2ff071afb2c0fec72 100644 (file)
--- a/src/pakfire/stripper.h
+++ b/src/pakfire/stripper.h
@@ -30,7 +30,7 @@ struct pakfire_stripper;
 #include <pakfire/pakfire.h>
 
 int pakfire_stripper_create(struct pakfire_stripper** stripper,
-       struct pakfire* pakfire, struct pakfire_jail* jail, const char* path);
+       struct pakfire* pakfire, pakfire_jail* jail, const char* path);
 
 struct pakfire_stripper* pakfire_stripper_ref(struct pakfire_stripper* self);
 struct pakfire_stripper* pakfire_stripper_unref(struct pakfire_stripper* self);

diff --git a/src/python/pakfire.c b/src/python/pakfire.c
index 5dbdac3213362ba4a8edff626e717c080f90188a..58cc029b38ba2d81f83d7333cbb58f04022a3524 100644 (file)
--- a/src/python/pakfire.c
+++ b/src/python/pakfire.c
@@ -565,7 +565,7 @@ static int Pakfire_execute_stdout_callback(pakfire_ctx* ctx, void* data,
 
 static PyObject* Pakfire_execute(PakfireObject* self, PyObject* args, PyObject* kwargs) {
        struct pakfire_input_buffer input = {};
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        pakfire_env* env = NULL;
        PyObject* mountpoint = NULL;
        const char** argv = NULL;

diff --git a/tests/libpakfire/cgroup.c b/tests/libpakfire/cgroup.c
index 80b786f65b5cb3f2b00bb6308c6df895a778beb9..4b4f74e4ff8c44537397c13c5a46c232847d0a04 100644 (file)
--- a/tests/libpakfire/cgroup.c
+++ b/tests/libpakfire/cgroup.c
@@ -104,7 +104,7 @@ FAIL:
 
 static int test_stats(const struct test* t) {
        pakfire_cgroup* cgroup = NULL;
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        pakfire_cgroup_stats stats;
@@ -124,7 +124,7 @@ static int test_stats(const struct test* t) {
 
        // Run a few things
        for (unsigned int i = 0; i < 3; i++) {
-               ASSERT_SUCCESS(pakfire_jail_exec_command(jail, argv, NULL, 0));
+               ASSERT_SUCCESS(pakfire_jail_execute_command(jail, argv, NULL, 0));
        }
 
        // Try reading the stats into some invalid space

diff --git a/tests/libpakfire/jail.c b/tests/libpakfire/jail.c
index a4e6989fc1753adaca8ba49fc7fbe86c30e460d8..e61330dead776b4c03619afe5d31e49eb11e8a7a 100644 (file)
--- a/tests/libpakfire/jail.c
+++ b/tests/libpakfire/jail.c
@@ -42,7 +42,7 @@ static const char* cmd_stat_ownership[] = {
 };
 
 static int test_create(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
 
        // Create a new jail
        ASSERT_SUCCESS(pakfire_jail_create(&jail, t->pakfire));
@@ -57,7 +57,7 @@ FAIL:
 }
 
 static int test_exit_code(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        const char* argv[] = {
@@ -68,7 +68,7 @@ static int test_exit_code(const struct test* t) {
        ASSERT_SUCCESS(pakfire_jail_create(&jail, t->pakfire));
 
        // Check if we receive the correct exit code
-       ASSERT_EQUALS(pakfire_jail_exec_command(jail, argv, NULL, 0), 123);
+       ASSERT_EQUALS(pakfire_jail_execute_command(jail, argv, NULL, 0), 123);
 
        // Success
        r = EXIT_SUCCESS;
@@ -81,7 +81,7 @@ FAIL:
 }
 
 static int test_segv(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        const char* argv[] = {
@@ -92,7 +92,7 @@ static int test_segv(const struct test* t) {
        ASSERT_SUCCESS(pakfire_jail_create(&jail, t->pakfire));
 
        // Check if we receive the correct exit code
-       ASSERT(pakfire_jail_exec_command(jail, argv, NULL, 0) == 139);
+       ASSERT(pakfire_jail_execute_command(jail, argv, NULL, 0) == 139);
 
        // Success
        r = EXIT_SUCCESS;
@@ -105,7 +105,7 @@ FAIL:
 }
 
 static int test_exec(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
        char* output = NULL;
        size_t length = 0;
@@ -114,7 +114,7 @@ static int test_exec(const struct test* t) {
        ASSERT_SUCCESS(pakfire_jail_create(&jail, t->pakfire));
 
        // Try to execute something
-       ASSERT_SUCCESS(pakfire_jail_exec_capture_output(jail, cmd_hello_world, NULL, 0, &output, &length));
+       ASSERT_SUCCESS(pakfire_jail_execute_capture_output(jail, cmd_hello_world, NULL, 0, &output, &length));
 
        // We should have some output
        ASSERT_STRING_EQUALS(output, "Hello World!\n");
@@ -135,7 +135,7 @@ FAIL:
 
 static int test_launch_into_cgroup(const struct test* t) {
        pakfire_cgroup* cgroup = NULL;
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        // Create a new cgroup
@@ -148,7 +148,7 @@ static int test_launch_into_cgroup(const struct test* t) {
        ASSERT_SUCCESS(pakfire_jail_set_cgroup(jail, cgroup));
 
        // Run command
-       ASSERT(pakfire_jail_exec_command(jail, cmd_hello_world, NULL, 0) == 0);
+       ASSERT(pakfire_jail_execute_command(jail, cmd_hello_world, NULL, 0) == 0);
 
        r = EXIT_SUCCESS;
 
@@ -164,7 +164,7 @@ FAIL:
 }
 
 static int test_nice(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        char* output = NULL;
        size_t length = 0;
        int r = EXIT_FAILURE;
@@ -184,7 +184,7 @@ static int test_nice(const struct test* t) {
        ASSERT_SUCCESS(pakfire_jail_nice(jail, 5));
 
        // Check if the nice level has been set
-       ASSERT_SUCCESS(pakfire_jail_exec_capture_output(jail, argv, NULL, 0, &output, &length));
+       ASSERT_SUCCESS(pakfire_jail_execute_capture_output(jail, argv, NULL, 0, &output, &length));
        ASSERT_STRING_EQUALS(output, "5\n");
 
        // Success
@@ -201,7 +201,7 @@ FAIL:
 
 static int test_memory_limit(const struct test* t) {
        pakfire_cgroup* cgroup = NULL;
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
 
@@ -218,10 +218,10 @@ static int test_memory_limit(const struct test* t) {
        ASSERT_SUCCESS(pakfire_cgroup_set_memory_limit(cgroup, 100 * 1024 * 1024));
 
        // Try to exhaust all memory
-       ASSERT_FAILURE(pakfire_jail_exec_command(jail, cmd_exhaust_memory, NULL, 0));
+       ASSERT_FAILURE(pakfire_jail_execute_command(jail, cmd_exhaust_memory, NULL, 0));
 
        // A fork bomb should also exhaust all memory
-       ASSERT_FAILURE(pakfire_jail_exec_command(jail, cmd_fork_bomb, NULL, 0));
+       ASSERT_FAILURE(pakfire_jail_execute_command(jail, cmd_fork_bomb, NULL, 0));
 
        // Success
        r = EXIT_SUCCESS;
@@ -239,7 +239,7 @@ FAIL:
 
 static int test_pid_limit(const struct test* t) {
        pakfire_cgroup* cgroup = NULL;
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        // Create cgroup
@@ -255,7 +255,7 @@ static int test_pid_limit(const struct test* t) {
        ASSERT_SUCCESS(pakfire_cgroup_set_pid_limit(cgroup, 100));
 
        // Try to fork as many processes as possible
-       ASSERT_FAILURE(pakfire_jail_exec_command(jail, cmd_fork_bomb, NULL, 0));
+       ASSERT_FAILURE(pakfire_jail_execute_command(jail, cmd_fork_bomb, NULL, 0));
 
        // Success
        r = EXIT_SUCCESS;
@@ -292,7 +292,7 @@ FAIL:
 }
 
 static int test_bind(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        const char* source = "/";
@@ -313,7 +313,7 @@ static int test_bind(const struct test* t) {
        ASSERT_SUCCESS(pakfire_jail_bind(jail, source, target, MS_RDONLY));
 
        // Check if the mount actually works
-       ASSERT_SUCCESS(pakfire_jail_exec_command(jail, argv, NULL, 0));
+       ASSERT_SUCCESS(pakfire_jail_execute_command(jail, argv, NULL, 0));
 
        // Success
        r = EXIT_SUCCESS;
@@ -354,7 +354,7 @@ static int callback_stdout(pakfire_ctx* ctx, void* data,
 }
 
 static int test_communicate(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        // How many lines to send?
@@ -382,17 +382,17 @@ FAIL:
 }
 
 static int test_send_one_signal(const struct test* t,
-               struct pakfire_jail* jail, const char* signal) {
+               pakfire_jail* jail, const char* signal) {
        const char* argv[] = {
                "/command", "send-signal", signal, NULL,
        };
 
        // Perform the command
-       return pakfire_jail_exec_command(jail, argv, NULL, 0);
+       return pakfire_jail_execute_command(jail, argv, NULL, 0);
 }
 
 static int test_send_signal(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        // Create a new jail
@@ -418,7 +418,7 @@ FAIL:
 }
 
 static int test_timeout(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        const char* argv[] = {
@@ -432,7 +432,7 @@ static int test_timeout(const struct test* t) {
        ASSERT_SUCCESS(pakfire_jail_set_timeout(jail, 1));
 
        // Check if we receive the correct exit code
-       ASSERT(pakfire_jail_exec_command(jail, argv, NULL, 0) == 139);
+       ASSERT(pakfire_jail_execute_command(jail, argv, NULL, 0) == 139);
 
        // Success
        r = EXIT_SUCCESS;
@@ -454,7 +454,7 @@ static int __callback(pakfire_ctx* ctx, void* data) {
 }
 
 static int test_callback(const struct test* t) {
-       struct pakfire_jail* jail = NULL;
+       pakfire_jail* jail = NULL;
        int r = EXIT_FAILURE;
 
        int i = 123;
@@ -463,7 +463,7 @@ static int test_callback(const struct test* t) {
        ASSERT_SUCCESS(pakfire_jail_create(&jail, t->pakfire));
 
        // Check if we receive the correct exit code
-       ASSERT(pakfire_jail_exec(jail, __callback, &i, 0) == 123);
+       ASSERT(pakfire_jail_execute(jail, __callback, &i, 0) == 123);
 
        // Success
        r = EXIT_SUCCESS;