Cppcheck report - GATE C/C++ Framework: gate/processes_posix.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/processes.h"

#include "gate/platforms.h"
#include "gate/debugging.h"
#include "gate/results.h"

#if defined(GATE_SYS_POSIX)

#include <unistd.h>
#include <dirent.h>
#include <sys/wait.h>
#include <sys/resource.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/wait.h>
#include <stdio.h>
#include <fcntl.h>
#include <grp.h>

#if defined(GATE_SYS_LINUX)
#	include <pty.h>
#elif defined(GATE_SYS_BSD)
#	include <termios.h>
#	if defined(GATE_SYS_FREEBSD)
#		include <libutil.h>
#	else
#		include <util.h>
#	endif
#elif defined(GATE_SYS_DARWIN)
#	include <util.h>
#	include "gate/platform/darwin/darwin_gate.h"
#endif

#if !defined(GATE_SYS_BSD)
#	include <utmp.h>
#endif
#include <dlfcn.h>
#include <errno.h>

#include "gate/times.h"
#include "gate/threading.h"
#include "gate/platforms.h"
#include "gate/platform/linux/procfs.h"
#include "gate/files.h"


typedef struct gate_process_stream_impl
{
    GATE_INTERFACE_VTBL(gate_process_stream)* vbl;
    gate_atomic_int_t	ref_counter;
    pid_t				target_pid;
    int					fd_stdin_write;
    int					fd_stdout_read;
    int					fd_stderr_read;
    char				peek_buffer[1024];
    gate_size_t			peek_buffer_used;
} gate_process_stream_impl_t;

static void gate_process_stream_release(void* thisptr)
{
    gate_process_stream_impl_t* stream = (gate_process_stream_impl_t*)thisptr;
    if (gate_atomic_int_dec(&stream->ref_counter) == 0)
    {
        if (stream->fd_stdin_write >= 0)
        {
            close(stream->fd_stdin_write);
            stream->fd_stdin_write = -1;
        }
        if (stream->fd_stdout_read >= 0)
        {
            close(stream->fd_stdout_read);
            stream->fd_stdout_read = -1;
        }
        if (stream->fd_stderr_read >= 0)
        {
            close(stream->fd_stderr_read);
            stream->fd_stderr_read = -1;
        }
        gate_mem_dealloc(stream);
    }
}
static char const* gate_process_stream_interface_name(void* thisptr)
{
    (void)thisptr;
    return GATE_INTERFACE_NAME_PROCESSSTREAM;
}
static int gate_process_stream_retain(void* thisptr)
{
    gate_process_stream_impl_t* stream = (gate_process_stream_impl_t*)thisptr;
    return gate_atomic_int_inc(&stream->ref_counter);
}

static gate_result_t is_process_termined(pid_t pid, gate_bool_t* ptr_terminated)
{
    siginfo_t info;
    int result;

    gate_mem_clear(&info, sizeof(info));
    result = waitid(P_PID, pid, &info, WEXITED | WNOHANG | WNOWAIT);
    if (0 == result)
    {
        if ((info.si_code == CLD_EXITED)
            || (info.si_code == CLD_KILLED)
            || (info.si_code == CLD_DUMPED)
            )
        {
            *ptr_terminated = true;
        }
        else
        {
            *ptr_terminated = false;
        }
        return GATE_RESULT_OK;
    }
    else
    {
        /* error */
        return gate_platform_print_last_error(NULL, 0);
    }
}

static gate_bool_t can_read_from_fd(int read_fd)
{
    fd_set read_set;
    struct timeval timeout;
    int result;

    timeout.tv_sec = 0;
    timeout.tv_usec = 0;

    FD_ZERO(&read_set);
    FD_SET(read_fd, &read_set);

    result = select(read_fd + 1, &read_set, NULL, NULL, &timeout);
    if (result < 0)
    {
        /* error */
        return false;
    }
    if (FD_ISSET(read_fd, &read_set))
    {
        return true;
    }
    return false;
}

static int await_read_fd_or_process_exit(pid_t pid, int read_fd)
{
    fd_set read_set;
    fd_set err_set;
    struct timeval timeout;
    int result;
<--- The scope of the variable 'result' can be reduced. [+]
The scope of the variable 'result' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

    for (;;)
    {
        timeout.tv_sec = 0;
        timeout.tv_usec = 100000;

        FD_ZERO(&read_set);
        FD_ZERO(&err_set);
        FD_SET(read_fd, &read_set);
        FD_SET(read_fd, &err_set);

        result = select(read_fd + 1, &read_set, NULL, &err_set, &timeout);
        if (result < 0)
        {
            /* error */
            return -1;
        }
        if (FD_ISSET(read_fd, &err_set))
        {
            /* error */
            return -1;
        }
        if (FD_ISSET(read_fd, &read_set))
        {
            /* can read */
            return 1;
        }

        if (pid > 0)
        {
            gate_bool_t is_terminated = false;
            gate_result_t wait_result = is_process_termined(pid, &is_terminated);

            if (GATE_FAILED(wait_result))
            {
                /* failed to detect process state */
                return -1;
            }
            else
            {
                if (is_terminated)
                {
                    /* process terminated, nothing else to read */
                    return 0;
                }

                /* else: continue */
            }
        }
    }
}

static gate_result_t gate_process_stream_read(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_process_stream_impl_t* stream = (gate_process_stream_impl_t*)thisptr;
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_int32_t errcode;
    ptrdiff_t result;
    int wait_result;<--- Shadowed declaration

    if (stream->peek_buffer_used > 0)
    {
        /* there is something in the peek buffer */

        if (bufferlength >= stream->peek_buffer_used)
        {
            /* we can read the whole peek-buffer */
            gate_mem_copy(buffer, stream->peek_buffer, stream->peek_buffer_used);
            if (returned) *returned = stream->peek_buffer_used;
            stream->peek_buffer_used = 0;
        }
        else
        {
            /* we can only return a subset of the peek buffer */
            gate_mem_copy(buffer, &stream->peek_buffer[0], bufferlength);
            gate_mem_copy(&stream->peek_buffer[0], &stream->peek_buffer[bufferlength], stream->peek_buffer_used - bufferlength);
            stream->peek_buffer_used -= bufferlength;
            if (returned) *returned = bufferlength;
        }
        return GATE_RESULT_OK;
    }

    wait_result = await_read_fd_or_process_exit(stream->target_pid, stream->fd_stdout_read);
    if (wait_result < 0)
    {
        return GATE_RESULT_FAILED;
    }
    else if (wait_result == 0)
    {
        if (returned)
        {
            *returned = 0;
        }
        return GATE_RESULT_OK;
    }

    /* data available to read */
    result = gate_posix_read(stream->fd_stdout_read, buffer, bufferlength);
    if (result < 0)
    {
        errcode = gate_platform_get_last_error();
        if (errcode == EIO)
        {
            gate_bool_t terminated = false;
            gate_result_t wait_result = is_process_termined(stream->target_pid, &terminated);<--- Shadow variable
            if (GATE_SUCCEEDED(wait_result) && terminated)
            {
                /* signal end-of-stream, as process was terminated */
                if (returned)
                {
                    *returned = 0;
                }
                return GATE_RESULT_OK;
            }
        }
        GATE_DEBUG_TRACE_MSG_VALUE("gate_process_stream_read() failed", errcode);
        ret = gate_platform_print_error(errcode, NULL, 0);
    }
    else
    {
        if (returned) *returned = (gate_size_t)result;
        ret = GATE_RESULT_OK;
    }
    return ret;
}
static gate_result_t gate_process_stream_peek(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_process_stream_impl_t* stream = (gate_process_stream_impl_t*)thisptr;
    gate_size_t copylen;
    ptrdiff_t result;
<--- The scope of the variable 'result' can be reduced. [+]
The scope of the variable 'result' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_int32_t errcode;

    if (stream->peek_buffer_used > 0)
    {
        /* there is already something in the peek buffer */
        copylen = bufferlength < stream->peek_buffer_used ? bufferlength : stream->peek_buffer_used;
        gate_mem_copy(buffer, &stream->peek_buffer[0], copylen);
        if (returned) *returned = copylen;
        return GATE_RESULT_OK;
    }

    if (can_read_from_fd(stream->fd_stdout_read))
    {
        /* read some bytes into peek-buffer */
        copylen = bufferlength < sizeof(stream->peek_buffer) ? bufferlength : sizeof(stream->peek_buffer);
        result = gate_posix_read(stream->fd_stdout_read, &stream->peek_buffer[0], copylen);
        if (result < 0)
        {
            /* read error */
            errcode = gate_platform_get_last_error();
            if (errcode == EIO)
            {
                gate_bool_t terminated = false;
                gate_result_t wait_result = is_process_termined(stream->target_pid, &terminated);
                if (GATE_SUCCEEDED(wait_result) && terminated)
                {
                    /* signal end-of-stream, as process was terminated */
                    if (returned)
                    {
                        *returned = 0;
                    }
                    return GATE_RESULT_ENDOFSTREAM;
                }
            }
            /* otherwise return native error info */
            return gate_platform_print_last_error(NULL, 0);
        }
        else if (result > 0)
        {
            /* peek-buffer is filled, return a copy via caller-supplied buffer */
            stream->peek_buffer_used = copylen;
            gate_mem_copy(buffer, &stream->peek_buffer[0], copylen);
            if (returned) *returned = copylen;
            return GATE_RESULT_OK;
        }
    }

    /* else: nothing available to read*/
    if (returned) *returned = 0;
    return GATE_RESULT_OK;
}
static gate_result_t gate_process_stream_write(void* thisptr, char const* buffer, gate_size_t bufferlength, gate_size_t* written)
{
    gate_process_stream_impl_t* stream = (gate_process_stream_impl_t*)thisptr;
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_int32_t errcode;
    ptrdiff_t result = gate_posix_write(stream->fd_stdin_write, buffer, bufferlength);
    if (result <= 0)
    {
        errcode = gate_platform_get_last_error();
        GATE_DEBUG_TRACE_MSG_VALUE("gate_process_stream_write() failed", errcode);
        ret = gate_platform_print_error(errcode, NULL, 0);
    }
    else
    {
        if (written) *written = (gate_size_t)result;
        ret = GATE_RESULT_OK;
    }
    return ret;
}
static gate_result_t gate_process_stream_flush(void* thisptr)
{
    gate_process_stream_impl_t* stream = (gate_process_stream_impl_t*)thisptr;
    fsync(stream->fd_stdin_write);
    return GATE_RESULT_OK;
}
static gate_result_t gate_process_stream_read_err(void* thisptr, char* buffer, gate_size_t bufferlength, gate_size_t* returned)
{
    gate_process_stream_impl_t* stream = (gate_process_stream_impl_t*)thisptr;
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_int32_t errcode;
    ptrdiff_t result = gate_posix_read(stream->fd_stderr_read, buffer, bufferlength);
    if (result < 0)
    {
        errcode = gate_platform_get_last_error();
        GATE_DEBUG_TRACE_MSG_VALUE("gate_process_stream_read() failed", errcode);
        ret = gate_platform_print_error(errcode, NULL, 0);
    }
    else
    {
        if (returned) *returned = (gate_size_t)result;
        ret = GATE_RESULT_OK;
    }
    return ret;
}
static gate_result_t gate_process_stream_get_resource(void* thisptr, gate_enumint_t resource_type, gate_uintptr_t* resource)
{
    gate_process_stream_impl_t* stream = (gate_process_stream_impl_t*)thisptr;
    gate_result_t ret;
    switch (resource_type)
    {
    case GATE_STREAM_RESOURCE_INPUT:
    {
        *resource = (gate_uintptr_t)stream->fd_stdin_write;
        ret = GATE_RESULT_OK;
        break;
    }
    case GATE_STREAM_RESOURCE_OUTPUT:
    {
        *resource = (gate_uintptr_t)stream->fd_stdout_read;
        ret = GATE_RESULT_OK;
        break;
    }
    case GATE_STREAM_RESOURCE_ERROR:
    {
        *resource = (gate_uintptr_t)stream->fd_stderr_read;
        ret = GATE_RESULT_OK;
        break;
    }
    default:
    {
        ret = GATE_RESULT_NOTSUPPORTED;
        break;
    }
    }
    return ret;
}

static GATE_INTERFACE_VTBL(gate_process_stream) gate_process_stream_vtbl;
static void gate_init_process_stream_vtbl()
{
    if (!gate_process_stream_vtbl.get_interface_name)
    {
        GATE_INTERFACE_VTBL(gate_process_stream) const local_vtbl =
        {
            &gate_process_stream_interface_name,
            &gate_process_stream_release,
            &gate_process_stream_retain,
            &gate_process_stream_read,
            &gate_process_stream_peek,
            &gate_process_stream_write,
            &gate_process_stream_flush,
            &gate_process_stream_get_resource,
            &gate_process_stream_read_err
        };
        gate_process_stream_vtbl = local_vtbl;
    }
}

static gate_process_stream_t* gate_process_stream_create(int fd_stdin_write, int fd_stdout_read, int fd_stderr_read)
{
    gate_process_stream_impl_t* stream = gate_mem_alloc(sizeof(gate_process_stream_impl_t));
    if (stream)
    {
        gate_init_process_stream_vtbl();
        stream->vbl = &gate_process_stream_vtbl;
        gate_atomic_int_set(&stream->ref_counter, 1);
        stream->target_pid = 0;
        stream->fd_stdin_write = fd_stdin_write;
        stream->fd_stdout_read = fd_stdout_read;
        stream->fd_stderr_read = fd_stderr_read;
    }
    return (gate_process_stream_t*)stream;
}


/*
typedef struct rlimit_setting
{
    int				setting;
    struct rlimit	limit;
} rlimit_setting_t;

typedef struct gate_process_exec_config
{
    gate_bool_t			set_uid;
    uid_t				uid;
    gate_bool_t			set_gid;
    gid_t				gid;

    gate_bool_t			new_session;
    gate_bool_t			new_terminal;

    rlimit_setting_t	limits[8];
    gate_size_t			limit_count;

} gate_process_exec_config_t;

gate_result_t gate_process_apply_exec_config(gate_process_exec_config_t const* config)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_size_t ndx;
    int result;
    char user_name[512];
    gate_size_t user_name_used;

    do
    {
        if(config == NULL) break;

        for(ndx = 0; ndx != config->limit_count; ++ndx)
        {
            if(-1 == setrlimit(config->limits[ndx].setting, &config->limits[ndx].limit))
            {
                ret = GATE_RESULT_PREPARATIONFAILED;
                break;
            }
        }
        GATE_BREAK_IF_FAILED(ret);

        if(config->set_uid && config->set_gid)
        {
            user_name_used = gate_posix_get_user_name(config->set_uid, user_name, sizeof(user_name));
            if(user_name_used != 0)
            {
                result = initgroups(user_name, config->gid);
                if(result != 0)
                {
                    GATE_DEBUG_TRACE("Failed to initialize groups");
                    GATE_DEBUG_TRACE_VALUE(gate_posix_errno(NULL));
                    break;
                }
            }
        }

        if(config->set_gid)
        {
            result = setgid(config->gid);
            if(result != 0)
            {
                GATE_DEBUG_TRACE("setgid() failed");
                GATE_DEBUG_TRACE_VALUE(gate_posix_errno(NULL));
                ret = GATE_RESULT_FAILED;
                break;
            }
        }

        if(config->set_uid)
        {
            result = setuid(config->uid);
            if(result != 0)
            {
                GATE_DEBUG_TRACE("setuid() failed");
                GATE_DEBUG_TRACE_VALUE(gate_posix_errno(NULL));
                ret = GATE_RESULT_FAILED;
                break;
            }
        }

        if(config->new_session)
        {
            result = setsid();
            if(result != 0)
            {
                GATE_DEBUG_TRACE("setsid() failed");
                GATE_DEBUG_TRACE_VALUE(gate_posix_errno(NULL));
                ret = GATE_RESULT_FAILED;
                break;
            }
        }

    } while(0);

    return ret;
}
*/

gate_result_t gate_process_get_id(gate_process_id_t* pid)
{
    gate_result_t ret;
    pid_t p = getpid();
    if (pid == NULL)
    {
        ret = GATE_RESULT_INVALIDARG;
    }
    else
    {
        *pid = (gate_process_id_t)p;
        ret = GATE_RESULT_OK;
    }
    return ret;
}
void gate_process_quit(int exitcode)
{
    _exit(exitcode);
}

#if defined(GATE_SYS_BSD) || defined(GATE_SYS_DARWIN)

#include <stdlib.h>
#include <sys/types.h>
#include <sys/sysctl.h>

#if defined(GATE_SYS_NETBSD)
/* NetBSD is special here and uses kinfo_proc2 for usermode, BSD's kinfo_proc is for kernel-mode only */

#	include <kvm.h>

typedef kvm_t* (*kvm_open_func_t)(char const* execfile, char const* corefile, char* swapfile, int flags, char* errstr);
typedef int	(*kvm_close_func_t)(kvm_t* kd);
typedef struct kinfo_proc2* (*kvm_getproc2_func_t)(kvm_t* kd, int op, int arg, size_t elemsize, int* cnt);

static kvm_open_func_t	kvm_open_func;
static kvm_close_func_t	kvm_close_func;
static kvm_getproc2_func_t	kvm_getproc2_func;

static void* volatile kvm_lib = NULL;

static void close_kvm_lib_atexit()
{
    if (NULL != kvm_lib)
    {
        void* handle = kvm_lib;
        kvm_lib = NULL;
        gate_posix_dlclose(handle);
    }
}

static gate_result_t load_kvm_library()
{
    if (!kvm_lib)
    {
        kvm_lib = gate_posix_dlopen("libkvm.so", RTLD_GLOBAL);
        if (kvm_lib == NULL)
        {
            return GATE_RESULT_NOTAVAILABLE;
        }
        gate_platform_atexit(&close_kvm_lib_atexit);
    }
    if (!kvm_open_func)
    {
        kvm_open_func = (kvm_open_func_t)gate_posix_dlsym(kvm_lib, "kvm_open");
    }
    if (!kvm_close_func)
    {
        kvm_close_func = (kvm_close_func_t)gate_posix_dlsym(kvm_lib, "kvm_close");
    }
    if (!kvm_getproc2_func)
    {
        kvm_getproc2_func = (kvm_getproc2_func_t)gate_posix_dlsym(kvm_lib, "kvm_getproc2");
    }
    return (kvm_open_func && kvm_close_func && kvm_getproc2_func) ? GATE_RESULT_OK : GATE_RESULT_NOTAVAILABLE;
}

static gate_result_t load_process_infobuffer(gate_process_infobuffer_t* target, struct kinfo_proc2 const* src)
{
    target->process.pid = src->p_pid;
    target->process.parent_pid = src->p_ppid;
    target->process.memory_used = src->p_vm_rssize;
    target->process.uptime = src->p_ustart_sec * 1000;
    target->process.cputime = src->p_uutime_sec * 1000;
    target->process.resources = 1;
    gate_str_print_text(target->namebuffer, sizeof(target->namebuffer), src->p_comm, gate_str_length(src->p_comm));
    target->process.name = target->namebuffer;
    gate_str_print_int64(target->ownerbuffer, sizeof(target->ownerbuffer), src->p_ruid);
    target->process.owner = target->ownerbuffer;
    return GATE_RESULT_OK;
}


gate_result_t gate_process_getinfo(gate_process_infobuffer_t* infobuffer, gate_process_id_t proc_id, gate_enumint_t flags)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    kvm_t* kvm = NULL;
    struct kinfo_proc2* procs = NULL;
    int procs_count = 0;
    char errmsg[_POSIX2_LINE_MAX] = GATE_INIT_EMPTY;

    do
    {
        ret = load_kvm_library();
        GATE_BREAK_IF_FAILED(ret);

        kvm = kvm_open_func(NULL, NULL, NULL, O_RDONLY, errmsg);
        if (kvm == NULL)
        {
            GATE_DEBUG_TRACE("kvm_open() failed");
            errmsg[_POSIX2_LINE_MAX - 1] = 0;
            GATE_DEBUG_TRACE(errmsg);
            ret = GATE_RESULT_NOTAVAILABLE;
            break;
        }
        procs = kvm_getproc2_func(kvm, KERN_PROC_PID, (int)proc_id, sizeof(struct kinfo_proc2), &procs_count);
        if ((procs == NULL) || (procs_count == 0))
        {
            GATE_DEBUG_TRACE("kvm_getprocs(KERN_PROC_PID) failed");
            ret = GATE_RESULT_NOMATCH;
            break;
        }

        ret = load_process_infobuffer(infobuffer, procs);
    } while (0);

    if (kvm != NULL)
    {
        kvm_close_func(kvm);
    }

    return ret;
}

#else /* OpenBSD and FreeBSD: */

#include <sys/user.h>

static gate_result_t load_process_infobuffer(gate_process_infobuffer_t* target, struct kinfo_proc const* src)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_mem_clear(target, sizeof(gate_process_infobuffer_t));
#if defined(GATE_SYS_OPENBSD)
    target->process.pid = src->p_pid;
    target->process.parent_pid = src->p_ppid;
    target->process.memory_used = src->p_vm_rssize;
    target->process.uptime = src->p_uutime_sec * 1000 + src->p_ustime_sec * 1000 + src->p_rtime_sec * 1000;
    target->process.resources = src->p_tid;
    gate_str_print_text(target->namebuffer, sizeof(target->namebuffer), src->p_comm, gate_str_length(src->p_comm));
    target->process.name = target->namebuffer;
    gate_str_print_int64(target->ownerbuffer, sizeof(target->ownerbuffer), src->p_ruid);
    target->process.owner = target->ownerbuffer;
#elif defined(GATE_SYS_DARWIN)
    target->process.pid = src->kp_proc.p_pid;
    target->process.parent_pid = src->kp_eproc.e_ppid;
    target->process.memory_used = 1; /* TODO */
    target->process.uptime = src->kp_proc.p_swtime;
    target->process.cputime = src->kp_proc.p_rtime.tv_sec * 1000 + src->kp_proc.p_rtime.tv_usec / 1000;
    target->process.resources = 1; /* TODO */
    gate_str_print_text(target->namebuffer, sizeof(target->namebuffer), src->kp_proc.p_comm, gate_str_length(src->kp_proc.p_comm));
    target->process.name = target->namebuffer;
    gate_str_print_text(target->ownerbuffer, sizeof(target->ownerbuffer), src->kp_eproc.e_login, gate_str_length(src->kp_eproc.e_login));
    target->process.owner = target->ownerbuffer;
#else
    target->process.pid = src->ki_pid;
    target->process.parent_pid = src->ki_ppid;
    target->process.memory_used = src->ki_size;
    target->process.uptime = src->ki_start.tv_sec * 1000 + src->ki_start.tv_usec / 1000;
    target->process.cputime = src->ki_runtime;
    target->process.resources = src->ki_numthreads;
    gate_str_print_text(target->namebuffer, sizeof(target->namebuffer), src->ki_comm, gate_str_length(src->ki_comm));
    target->process.name = target->namebuffer;
    gate_str_print_text(target->ownerbuffer, sizeof(target->ownerbuffer), src->ki_login, gate_str_length(src->ki_login));
    target->process.owner = target->ownerbuffer;
#endif

    return ret;
}

gate_result_t gate_process_getinfo(gate_process_infobuffer_t* infobuffer, gate_process_id_t proc_id, gate_enumint_t flags)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    int names[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, (int)proc_id, sizeof(struct kinfo_proc), 1 };
#if defined(GATE_SYS_OPENBSD)
    unsigned name_len = 6;
#else
    unsigned name_len = 4;
#endif
    char buffer[8192 + 4096];
    size_t buffer_len = sizeof(buffer);
    int result;
<--- The scope of the variable 'result' can be reduced. [+]
The scope of the variable 'result' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

    do
    {
        result = sysctl(names, name_len, &buffer[0], &buffer_len, NULL, 0);
        if (result < 0)
        {
            GATE_DEBUG_TRACE_PLATFORM_ERROR("sysctl() failed");
            GATE_DEBUG_TRACE_MSG_VALUE("PID", proc_id);
            ret = GATE_RESULT_FAILED;
            break;
        }
        ret = load_process_infobuffer(infobuffer, (struct kinfo_proc const*)buffer);
    } while (0);
    return ret;
}

#endif /* NETBSD or OPEN/FREEBSD variants for gate_process_getinfo() */


#if defined(GATE_SYS_DARWIN)

static gate_bool_t publish_process_info(int pid, gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    gate_process_infobuffer_t info;

    int ppid = 0;
    unsigned int uid = 0;
    unsigned int gid = 0;
    unsigned long long start_time = 0;
    gate_result_t result;

    gate_mem_clear(&info, sizeof(info));

    info.process.pid = pid;

    result = gate_darwin_get_pid_info(pid, &ppid, &uid, &gid, &start_time, info.namebuffer, sizeof(info.namebuffer));
    if (GATE_SUCCEEDED(result))
    {
        info.process.parent_pid = ppid;
        info.process.uptime = (gate_int64_t)start_time;
        info.process.cputime = (gate_int64_t)start_time; /* TODO */
        info.process.name = info.namebuffer;
    }

    if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_ENUM_PATH))
    {
        result = gate_darwin_get_pid_path(pid, info.pathbuffer, sizeof(info.pathbuffer), NULL);
        if (GATE_SUCCEEDED(result))
        {
            info.process.path = info.pathbuffer;
        }
    }

    if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_ENUM_MEMORY))
    {
        /* TODO */
    }

    if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_ENUM_MEMORY))
    {
        /* TODO */
    }

    return callback(&info.process, userparam);
}

static gate_result_t darwin_process_enum(gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    int pids[1024 + 512 + 256];
    gate_size_t pids_used = 0;
    gate_size_t ndx;
    gate_result_t result = gate_darwin_list_pids(&pids[0], sizeof(pids) / sizeof(pids[0]), &pids_used);
    GATE_RETURN_IF_FAILED(result);
    if (callback)
    {
        for (ndx = 0; ndx != pids_used; ++ndx)
        {
            if (!publish_process_info(pids[ndx], callback, userparam, flags))
            {
                break;
            }
        }
    }
    return GATE_RESULT_OK;
}

#elif defined(GATE_SYS_FREEBSD)

typedef struct kinfo_proc* (*kinfo_getallproc_func_t)(int* cntp);

static void* volatile libutil = NULL;

static void close_libutil_atexit()
{
    if (NULL != libutil)
    {
        void* handle = libutil;
        libutil = NULL;
        gate_posix_dlclose(handle);
    }
}

static kinfo_getallproc_func_t load_getallproc()
{
    if (libutil == NULL)
    {
        libutil = gate_posix_dlopen("libutil.so", RTLD_GLOBAL);
        if (NULL == libutil)
        {
            return NULL;
        }
        else
        {
            gate_platform_atexit(&close_libutil_atexit);
        }
    }
    return (kinfo_getallproc_func_t)gate_posix_dlsym(libutil, "kinfo_getallproc");
}

static gate_result_t freebsd_process_enum(gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    int procs_count = 0;
    int ndx;
    gate_process_infobuffer_t infobuffer;
    struct kinfo_proc* procs;
    kinfo_getallproc_func_t kinfo_getallproc_func = load_getallproc();

    if (!kinfo_getallproc_func)
    {
        return GATE_RESULT_NOTSUPPORTED;
    }

    procs = kinfo_getallproc_func(&procs_count);

    if (procs == NULL)
    {
        return GATE_RESULT_FAILED;
    }

    for (ndx = 0; ndx < procs_count; ++ndx)
    {
        gate_result_t result = load_process_infobuffer(&infobuffer, &procs[ndx]);
        if (GATE_FAILED(result))
        {
            continue;
        }
        if (!callback(&infobuffer.process, userparam))
        {
            break;
        }
    }

    free(procs);
    return GATE_RESULT_OK;
}

#elif defined(GATE_SYS_OPENBSD)

static gate_result_t openbsd_process_enum(gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), 0 };
    unsigned mib_len = sizeof(mib) / sizeof(mib[0]);
    gate_process_infobuffer_t info_buffer;
    char buffer[8192 + 4096];
    char* ptr_buffer = &buffer[0];
    size_t bufferlen = 0;
    struct kinfo_proc* procs;
<--- The scope of the variable 'procs' can be reduced. [+]
The scope of the variable 'procs' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    size_t procs_count;
<--- The scope of the variable 'procs_count' can be reduced. [+]
The scope of the variable 'procs_count' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

    do
    {
        /* retrieve required buffer len */
        if (0 != sysctl(mib, mib_len, NULL, &bufferlen, NULL, 0))
        {
            GATE_DEBUG_TRACE_PLATFORM_ERROR("sysctl() failed");
            ret = GATE_RESULT_NOTAVAILABLE;
            break;
        }

        if (bufferlen > sizeof(buffer))
        {
            ptr_buffer = gate_mem_alloc(bufferlen);
            if (ptr_buffer == NULL)
            {
                GATE_DEBUG_TRACE_MSG_VALUE("Out of memory", bufferlen);
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
        }

        procs_count = bufferlen / sizeof(struct kinfo_proc);
        mib[5] = procs_count;

        if (0 != sysctl(mib, mib_len, ptr_buffer, &bufferlen, NULL, 0))
        {
            GATE_DEBUG_TRACE_PLATFORM_ERROR("sysctl() failed");
            ret = GATE_RESULT_FAILED;
            break;
        }

        procs = (struct kinfo_proc*)ptr_buffer;
        while (procs_count-- > 0)
        {
            gate_result_t result = load_process_infobuffer(&info_buffer, procs);
            if (GATE_SUCCEEDED(result) && (callback != NULL))
            {
                if (!callback(&info_buffer.process, userparam))
                {
                    break;
                }
            }
            ++procs;
        }
        ret = GATE_RESULT_OK;
    } while (0);

    if ((ptr_buffer != NULL) && (ptr_buffer != &buffer[0]))
    {
        /* free allocated memory */
        gate_mem_dealloc(ptr_buffer);
    }
    return ret;
}

#elif defined(GATE_SYS_NETBSD)

static gate_result_t netbsd_process_enum(gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    kvm_t* kvm = NULL;
    struct kinfo_proc2* procs = NULL;
    int procs_count = 0;
    int ndx;
    gate_process_infobuffer_t infobuffer;
    char errbuf[_POSIX2_LINE_MAX];

    do
    {
        ret = load_kvm_library();
        GATE_BREAK_IF_FAILED(ret);

        kvm = kvm_open_func(NULL, NULL, NULL, O_RDONLY, errbuf);
        if (kvm == NULL)
        {
            GATE_DEBUG_TRACE("kvm_open() failed");
            errbuf[_POSIX2_LINE_MAX - 1] = 0;
            GATE_DEBUG_TRACE(errbuf);
            ret = GATE_RESULT_NOTAVAILABLE;
            break;
        }

        procs = kvm_getproc2_func(kvm, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc2), &procs_count);
        if ((procs == NULL) || (procs_count == 0))
        {
            /* finding no processes is an error, we should at least find our own process */
            GATE_DEBUG_TRACE("kvm_getprocs(KERN_PROC_ALL) failed");
            ret = GATE_RESULT_FAILED;<--- Variable 'ret' is reassigned a value before the old one has been used.
        }

        /* success case: iterator over infos */
        ret = GATE_RESULT_OK;<--- Variable 'ret' is reassigned a value before the old one has been used.
        for (ndx = 0; ndx != procs_count; ++ndx, ++procs)
        {
            gate_result_t result = load_process_infobuffer(&infobuffer, procs);
            if (GATE_FAILED(result))
            {
                continue;
            }
            if (callback)
            {
                if (!callback(&infobuffer.process, userparam))
                {
                    break;
                }
            }
        }
    } while (0);

    if (kvm != NULL)
    {
        kvm_close_func(kvm);
    }
    return ret;
}

#endif

#else /* Linux PROCFS */

gate_result_t gate_process_getinfo(gate_process_infobuffer_t* infobuffer, gate_process_id_t proc_id, gate_enumint_t flags)
{
    gate_result_t ret = GATE_RESULT_NOTAVAILABLE;
    gate_size_t namepos;
    gate_procfs_proc_stat_t proc_stat;
    gate_procfs_memstat_t mem_stat;
    gate_uint64_t page_size;
    gate_uint64_t ticks_per_second;
    gate_uint64_t starttime_after_boot_ms;
    gate_int64_t system_up_time_ms;
    gate_posix_user_info_t user_info;
    gate_result_t result;
    int proc_uid;

    gate_mem_clear(infobuffer, sizeof(gate_process_infobuffer_t));

    infobuffer->process.pid = proc_id;

    if (gate_procfs_get_exe_path(proc_id, infobuffer->pathbuffer, sizeof(infobuffer->pathbuffer)))
    {
        infobuffer->process.path = infobuffer->pathbuffer;
        ret = GATE_RESULT_OK;
    }

    if (gate_procfs_load_proc_stat(proc_id, &proc_stat))
    {
        infobuffer->process.parent_pid = proc_stat.ppid;

        if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_ENUM_TIMES))
        {
            ticks_per_second = (gate_uint64_t)sysconf(_SC_CLK_TCK);
            starttime_after_boot_ms = (gate_int64_t)proc_stat.starttime * 1000ULL / ticks_per_second;

            system_up_time_ms = gate_procfs_get_uptime_ms();

            infobuffer->process.uptime = system_up_time_ms - starttime_after_boot_ms;
            if (infobuffer->process.uptime < 0) infobuffer->process.uptime = 0;
            infobuffer->process.cputime = (gate_uint64_t)(proc_stat.utime + proc_stat.stime) * 1000ULL / ticks_per_second;
            if (infobuffer->process.cputime < 0) infobuffer->process.cputime = 0;
        }
        ret = GATE_RESULT_OK;
    }

    if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_ENUM_NAME))
    {
        if (infobuffer->process.path != NULL)
        {
            namepos = gate_str_char_pos_last(infobuffer->process.path, gate_str_length(infobuffer->process.path), '/');
            if (namepos != GATE_STR_NPOS)
            {
                infobuffer->process.name = &infobuffer->process.path[namepos + 1];
            }
        }
        if (infobuffer->process.name == NULL)
        {
            gate_str_print_uint64(infobuffer->namebuffer, sizeof(infobuffer->namebuffer), proc_id);
            infobuffer->process.name = infobuffer->namebuffer;
        }
    }

    if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_ENUM_OWNER))
    {
        if (gate_procfs_get_exe_owner(proc_id, &proc_uid, NULL))
        {
            result = gate_posix_get_user_info(proc_uid, &user_info);
            if (GATE_SUCCEEDED(result))
            {
                gate_str_print_text(infobuffer->ownerbuffer, sizeof(infobuffer->ownerbuffer),
                    user_info.name, gate_str_length(user_info.name));
                infobuffer->process.owner = infobuffer->ownerbuffer;
            }
        }
    }

    if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_ENUM_MEMORY))
    {
        if (gate_procfs_get_memstat(proc_id, &mem_stat))
        {
            page_size = sysconf(_SC_PAGESIZE);
            if (page_size == 0)
            {
                page_size = 4096;
            }
            infobuffer->process.memory_used = (gate_uint64_t)mem_stat.resident * page_size;
        }
    }

    if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_ENUM_RESOURCES))
    {
        infobuffer->process.resources = gate_procfs_get_open_fds(proc_id);
        if (infobuffer->process.resources < 0) infobuffer->process.resources = 0;
    }

    return ret;
}

#endif

gate_result_t gate_process_enum(gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    DIR* dir;

#if defined(GATE_SYS_DARWIN)
    ret = darwin_process_enum(callback, userparam, flags);
#elif defined(GATE_SYS_BSD)

#if defined(GATE_SYS_FREEBSD)
    ret = freebsd_process_enum(callback, userparam, flags);
#elif defined(GATE_SYS_OPENBSD)
    ret = openbsd_process_enum(callback, userparam, flags);
#elif defined(GATE_SYS_NETBSD)
    ret = netbsd_process_enum(callback, userparam, flags);
#endif

    if (GATE_SUCCEEDED(ret))
    {
        /* we have a result, we are done */
        return GATE_RESULT_OK;
    }
    /* otherwise, continue with linux/procfs approach */

#endif /* GATE_SYS_BSD */

    /* linux procfs: */
    dir = opendir("/proc");

    if (dir != NULL)
    {
        struct dirent* entry;
        while (NULL != (entry = readdir(dir)))
        {
            gate_process_infobuffer_t proc_data;
            gate_uint64_t procid = 0;
            gate_size_t entrylen = gate_str_length(entry->d_name);
            gate_size_t parselen = gate_str_parse_uint64(entry->d_name, entrylen, &procid);
            if (parselen == entrylen)
            {
                /* seems to be a numeric process id */
                ret = gate_process_getinfo(&proc_data, (gate_process_id_t)procid, flags);
                if (GATE_SUCCEEDED(ret))
                {
                    if (false == callback(&proc_data.process, userparam))
                    {
                        break;
                    }
                }
            }
        }
        closedir(dir);
        ret = GATE_RESULT_OK;
    }
    return ret;
}


gate_result_t gate_process_start(gate_string_t const* executablepath,
    gate_string_t const* args, gate_size_t argcount,
    gate_string_t const* workdir, gate_string_t const* envvars, gate_size_t envvarcount, gate_enumint_t flags,
    gate_process_handle_t* result_handle,
    gate_process_id_t* result_pid,
    gate_process_stream_t** result_stream
)
{
    return gate_process_start_ex(executablepath, args, argcount,
        workdir, envvars, envvarcount, flags,
        NULL, NULL, NULL,
        result_handle, result_pid, result_stream);
}


static char* gate_process_build_argarray(gate_string_t const* args, gate_size_t argcount, char** buffer, gate_size_t maxargs)
{
    char* ret;
    char* ptr;
    gate_size_t ndx;
    gate_size_t byte_size = 0;
    gate_size_t len;
    gate_size_t buffer_ndx = 0;

    if (argcount >= maxargs) argcount = maxargs - 1;

    for (ndx = 0; ndx < argcount; ++ndx)
    {
        byte_size += args[ndx].length + 1;
    }
    byte_size += 2;

    ret = gate_mem_alloc(byte_size);
    if (ret != NULL)
    {
        ptr = ret;
        for (ndx = 0; ndx < argcount; ++ndx)
        {
            len = gate_str_print_text(ptr, args[ndx].length + 1, args[ndx].str, args[ndx].length);
            buffer[buffer_ndx++] = ptr;
            ptr += (len + 1);
        }
        ptr[0] = 0;
        buffer[buffer_ndx] = NULL;
    }
    return ret;
}

static int gate_get_open_max(void)
{
#ifdef  OPEN_MAX
    return OPEN_MAX;
#else
    static volatile int cached_max = 0;
    long cnf_open_max;
<--- The scope of the variable 'cnf_open_max' can be reduced. [+]
The scope of the variable 'cnf_open_max' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    if (cached_max == 0)
    {
        cnf_open_max = sysconf(_SC_OPEN_MAX);
        if (cnf_open_max <= 0)
        {
            cached_max = 1024;
        }
        else
        {
            cached_max = (int)cnf_open_max;
        }
    }
    return cached_max;
#endif
}


static void close_private_file_descriptor(gate_bool_t exclude_inheritable_fds, int preserved_fd)
{
    int inheritable_fds[1024];
    gate_size_t inheritable_count = 0;
    int fd_max = gate_get_open_max();
    int fd;
    size_t index;
    gate_bool_t exclude_fd = false;

    inheritable_fds[0] = preserved_fd;
    inheritable_count = 1;

    if (exclude_inheritable_fds)
    {
        inheritable_count = gate_posix_get_inheritable_fds(
            &inheritable_fds[1], sizeof(inheritable_fds) / sizeof(inheritable_fds[0]) - 1);
        ++inheritable_count;
    }


    for (fd = STDERR_FILENO + 1; fd < fd_max; ++fd)
    {
        exclude_fd = false;
        for (index = 0; index != inheritable_count; ++index)
        {
            if (fd == inheritable_fds[index])
            {
                exclude_fd = true;
                break;
            }
        }
        if (!exclude_fd)
        {
            gate_posix_close(fd);
        }
    }
}

static gate_result_t gate_process_switch_user(char const* username)
{
    gate_result_t ret;
    gate_posix_user_info_t user_info;
    int result;
<--- The scope of the variable 'result' can be reduced. [+]
The scope of the variable 'result' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

    do
    {
        ret = gate_posix_resolve_user_info(username, &user_info);
        GATE_BREAK_IF_FAILED(ret);

        result = initgroups(user_info.name, user_info.gid);
        if (-1 == result)
        {
            GATE_DEBUG_TRACE_MSG_VALUE("initgroups failed()", gate_posix_errno(NULL));
        }

        result = setgid(user_info.gid);
        if (result != 0)
        {
            GATE_DEBUG_TRACE_MSG_VALUE("setgid failed()", gate_posix_errno(NULL));
            ret = gate_platform_print_last_error(NULL, 0);
            break;
        }

        result = setuid(user_info.uid);
        if (result != 0)
        {
            GATE_DEBUG_TRACE_MSG_VALUE("setuid failed()", gate_posix_errno(NULL));
            ret = gate_platform_print_last_error(NULL, 0);
            break;
        }
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}

typedef int(*openpty_func_t)(int* amaster, int* aslave, char const* name, struct termios const* termp, struct winsize const* winp);
typedef int(*login_tty_func_t)(int fd);

static openpty_func_t openpty_func;
static login_tty_func_t login_tty_func;

static gate_bool_t are_pty_functions_loaded()
{
    return (openpty_func != NULL) && (login_tty_func != NULL);
}

static gate_bool_t try_load_pty_functions(void* libhandle)
{
    openpty_func = (openpty_func_t)gate_posix_dlsym(libhandle, "openpty");
    login_tty_func = (login_tty_func_t)gate_posix_dlsym(libhandle, "login_tty");
    return are_pty_functions_loaded();
}

static char const* util_libs[] =
{
    "libutil.so",
    "libutil.so.1"
};
static unsigned const util_libs_count = sizeof(util_libs) / sizeof(util_libs[0]);

static void* volatile pty_lib_handle = NULL;

static void close_pty_lib_atexit()
{
    if (NULL != pty_lib_handle)
    {
        void* handle = pty_lib_handle;
        pty_lib_handle = NULL;
        gate_posix_dlclose(handle);
    }
}

static gate_bool_t load_pty_functions()
{
    if (are_pty_functions_loaded())
    {
        return true;
    }

    openpty_func = (openpty_func_t)gate_posix_global_sym("openpty");
    login_tty_func = (login_tty_func_t)gate_posix_global_sym("login_tty");
    if (are_pty_functions_loaded())
    {
        return true;
    }

    unsigned ndx;
    for (ndx = 0; ndx != util_libs_count; ++ndx)
    {
        void* lib_handle = gate_posix_dlopen(util_libs[ndx], RTLD_GLOBAL);
        if (lib_handle)
        {
            if (try_load_pty_functions(lib_handle))
            {
                pty_lib_handle = lib_handle;
                gate_platform_atexit(&close_pty_lib_atexit);
                return true;
            }
            else
            {
                gate_posix_dlclose(lib_handle);
            }
        }
    }
    return false;
}

static gate_result_t gate_process_exec(gate_string_t const* executablepath, gate_string_t const* args, gate_size_t argcount,
    gate_string_t const* workdir, gate_string_t const* envvars, gate_size_t envvarcount, gate_enumint_t flags,
    char const* sessionlocation,
    char const* username, char const* password, int preserved_fd,
    int* ptr_tty_fd,
    int* new_std_in, int* new_std_out, int* new_std_err
)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    int result;
    char* process_args[256];
    char* process_vars[256];
    char  new_work_dir[GATE_MAX_FILEPATH_LENGTH];
    char  exe_path[GATE_MAX_FILEPATH_LENGTH];
    char* process_args_buffer = NULL;
    char* process_vars_buffer = NULL;

    do
    {
        if (!gate_string_is_empty(workdir))
        {
            GATE_STRING_TO_BUFFER(workdir, new_work_dir);
            if (-1 == chdir(new_work_dir))
            {
                ret = GATE_RESULT_INVALIDINPUT;
                break;
            }
        }

        if (!gate_str_is_empty(username))
        {
            ret = gate_process_switch_user(username);
            GATE_BREAK_IF_FAILED(ret);
        }

        if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_START_NEWSESSION))
        {
            result = setsid();
            if (result != 0)
            {
                GATE_DEBUG_TRACE_MSG_VALUE("setsid() failed", gate_posix_errno(NULL));
                ret = GATE_RESULT_FAILED;
                break;
            }
        }

        process_args_buffer = gate_process_build_argarray(args, argcount, &process_args[1], sizeof(process_args) / sizeof(process_args[0]) - 1);
        process_vars_buffer = gate_process_build_argarray(envvars, envvarcount, process_vars, sizeof(process_vars) / sizeof(process_vars[0]));

        GATE_STRING_TO_BUFFER(executablepath, exe_path);
        process_args[0] = exe_path;

        if (ptr_tty_fd)
        {
            /* login to terminal and set STD* to terminal fd */
            if (login_tty_func(*ptr_tty_fd) == -1)
            {
                GATE_DEBUG_TRACE_MSG_VALUE("login_tty() failed", gate_posix_errno(NULL));
                ret = GATE_RESULT_FAILED;
                break;
            }
        }
        else
        {
            /* redirect parent-pipes to STD* fds */
            if (new_std_in)
            {
                dup2(*new_std_in, STDIN_FILENO);
                close(*new_std_in);
            }
            if (new_std_out)
            {
                dup2(*new_std_out, STDOUT_FILENO);
                close(*new_std_out);
            }
            if (new_std_err)
            {
                dup2(*new_std_err, STDERR_FILENO);
                close(*new_std_err);
            }
        }

        close_private_file_descriptor(!GATE_FLAG_ENABLED(flags, GATE_PROCESS_START_NOINHERIT), preserved_fd);

        if (envvars)
        {
            execve(exe_path, process_args, process_vars);
        }
        else
        {
            execv(exe_path, process_args);
        }

        ret = GATE_RESULT_UNKNOWNERROR;

    } while (0);

    if (process_args_buffer)
    {
        gate_mem_dealloc(process_args_buffer);
    }
    if (process_vars_buffer)
    {
        gate_mem_dealloc(process_vars_buffer);
    }
    return ret;
}


#define INVALID_FD (-1)

static void close_valid_fd(int fd)
{
    if (fd != INVALID_FD)
    {
        close(fd);
    }
}

gate_result_t gate_process_start_ex(gate_string_t const* executablepath,
    gate_string_t const* args, gate_size_t argcount,
    gate_string_t const* workdir, gate_string_t const* envvars, gate_size_t envvarcount, gate_enumint_t flags,
    char const* sessionlocation,
    char const* username, char const* password,
    gate_process_handle_t* result_handle,
    gate_process_id_t* result_pid,
    gate_process_stream_t** result_stream
)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    int failpipes[2] = { INVALID_FD, INVALID_FD };
    int std_in_pipe[2] = { INVALID_FD, INVALID_FD };	/* stdin of child process */
    int std_out_pipe[2] = { INVALID_FD, INVALID_FD };	/* stdout of child process */
    int std_err_pipe[2] = { INVALID_FD, INVALID_FD };	/* stderr of child process */
    pid_t process_id = -1;
    int term_master = INVALID_FD;
    int term_slave = INVALID_FD;
    char term_slave_name[1024];
    char const* ptr_term_slave_name = NULL;
    gate_process_stream_t* proc_stream = NULL;

    int status = 0;
    ssize_t readlen;
<--- The scope of the variable 'readlen' can be reduced. [+]
The scope of the variable 'readlen' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    ssize_t writelen;
<--- The scope of the variable 'writelen' can be reduced. [+]
The scope of the variable 'writelen' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_result_t process_exec_error = 0;

    do
    {
        if (result_stream)
        {
            if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_START_NEWTERMINAL))
            {
                /* child process will run in a pseudo terminal, parent controls master-side */
                if (!load_pty_functions())
                {
                    ret = GATE_RESULT_NOTSUPPORTED;
                    break;
                }
                if (openpty_func(&term_master, &term_slave, term_slave_name, NULL, NULL) == -1)
                {
                    ret = GATE_RESULT_OUTOFRESOURCES;
                    break;
                }
                ptr_term_slave_name = &term_slave_name[0];

                /* parent process read/write ends are set to terminal-master */
                std_in_pipe[1] = term_master;
                std_out_pipe[0] = dup(term_master);
                std_err_pipe[0] = dup(term_master);
                term_master = INVALID_FD;
            }
            else
            {
                /* child process i/o will be directed to pipes controlled by parent */
                if (pipe(std_in_pipe) != 0)
                {
                    ret = GATE_RESULT_OUTOFRESOURCES;
                    break;
                }
                if (pipe(std_out_pipe) != 0)
                {
                    ret = GATE_RESULT_OUTOFRESOURCES;
                    break;
                }
                if (GATE_FLAG_ENABLED(flags, GATE_PROCESS_START_USESTDERR))
                {
                    if (pipe(std_err_pipe) != 0)
                    {
                        ret = GATE_RESULT_OUTOFRESOURCES;
                        break;
                    }
                }
                else
                {
                    std_err_pipe[0] = dup(std_out_pipe[0]);
                    std_err_pipe[1] = dup(std_out_pipe[1]);
                }
            }

            proc_stream = gate_process_stream_create(std_in_pipe[1], std_out_pipe[0], std_err_pipe[0]);
            if (!proc_stream)
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
            /* fds are now handled by stream object */
            std_in_pipe[1] = INVALID_FD;
            std_out_pipe[0] = INVALID_FD;
            std_err_pipe[0] = INVALID_FD;
        }

        if (pipe(failpipes) != 0)
        {
            ret = GATE_RESULT_OUTOFRESOURCES;
            break;
        }

        process_id = fork();
        if (process_id == -1)
        {
            /* fork has failed */
            ret = GATE_RESULT_EXECUTIONFAILED;
            break;
        }

        if (process_id == 0)
        {
            /* child process */
            close(failpipes[0]);	/* close read descriptor of fail-detector-pipe */
            failpipes[0] = INVALID_FD;
            fcntl(failpipes[1], F_SETFD, FD_CLOEXEC);	/* auto-close on-exec on write descriptor of fail-detector-pipe */

            process_exec_error = gate_process_exec(
                executablepath, args, argcount, workdir, envvars, envvarcount, flags,
                sessionlocation, username, password,
                failpipes[1], 										/* exclude failpipe from auto-close */
                (term_slave != INVALID_FD) ? &term_slave : NULL,	/* use terminal-slave fd if available */
                result_stream ? &std_in_pipe[0] : NULL, 			/* redirect std-in */
                result_stream ? &std_out_pipe[1] : NULL, 			/* redirect std-out */
                result_stream ? &std_err_pipe[1] : NULL				/* redirect std-err */
            );

            writelen = write(failpipes[1], &process_exec_error, sizeof(process_exec_error));
            _exit(GATE_RESULT_TO_EXITCODE(process_exec_error));
            ret = GATE_RESULT_UNKNOWNERROR;
            break;
        }

        /* parent process */
        close_valid_fd(term_slave);
        term_slave = INVALID_FD;

        close(failpipes[1]);	/* close write descriptor of fail-detector-pipe*/
        failpipes[1] = INVALID_FD;

        readlen = read(failpipes[0], &process_exec_error, sizeof(process_exec_error));
        close(failpipes[0]);
        failpipes[0] = INVALID_FD;

        if (readlen > 0)
        {
            /* child process has failed to prepare exec */
            ret = process_exec_error;
        }
        else
        {
            /* when reading from 'failpipe' fails, then everything seems to be OK */

            if (result_stream)
            {
                *result_stream = proc_stream;
                if (proc_stream)
                {
                    ((gate_process_stream_impl_t*)proc_stream)->target_pid = process_id;
                    gate_object_retain(proc_stream);
                }
            }

            if (result_pid != NULL)
            {
                *result_pid = (gate_process_id_t)process_id;
            }
            if (result_handle != NULL)
            {
                *result_handle = (gate_process_handle_t)(gate_intptr_t)process_id;
                process_id = 0; /* protect process_id from being cleaned up */
            }

            ret = GATE_RESULT_OK;
        }
    } while (0);

    if (process_id > 0)
    {
        /* detach process */
        waitpid(process_id, &status, WNOHANG);
    }

    close_valid_fd(failpipes[1]);
    close_valid_fd(failpipes[0]);
    close_valid_fd(std_in_pipe[1]);
    close_valid_fd(std_in_pipe[0]);
    close_valid_fd(std_out_pipe[1]);
    close_valid_fd(std_out_pipe[0]);
    close_valid_fd(std_err_pipe[1]);
    close_valid_fd(std_err_pipe[0]);
    close_valid_fd(term_master);
    close_valid_fd(term_slave);

    if (proc_stream)
    {
        gate_object_release(proc_stream);
    }

    return ret;
}
gate_result_t gate_process_close(gate_process_handle_t* handle)
{
    gate_result_t ret;
    pid_t pid;
    int status;
    pid_t result;

    if (!handle || (*handle == GATE_PROCESS_HANDLE_INVALID))
    {
        ret = GATE_RESULT_OK;
    }
    else
    {
        pid = (pid_t)(gate_intptr_t)*handle;
        result = waitpid(pid, &status, WNOHANG);
        if (result == -1)
        {
            ret = GATE_RESULT_FAILED;
        }
        else
        {
            *handle = GATE_PROCESS_HANDLE_INVALID;
            ret = GATE_RESULT_OK;
        }
    }

    return ret;
}
gate_result_t gate_process_get_exitcode(gate_process_handle_t* handle, int* exitcode)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    pid_t pid;
    siginfo_t si = GATE_INIT_EMPTY;
    int result;
    int status;<--- Unused variable: status
    gate_timecounter_t tcbegin, tcnow;
    gate_int64_t timediff;
    gate_int64_t timeoutus;
    gate_uint32_t sleepcounter;

    if (!handle || (*handle == GATE_PROCESS_HANDLE_INVALID))
    {
        return GATE_RESULT_INVALIDSTATE;
    }

    pid = (pid_t)(gate_intptr_t)*handle;

#if defined(GATE_SYS_OPENBSD)
    result = waitpid(pid, &status, WNOHANG);
    if (-1 == result)
    {
        return GATE_RESULT_FAILED;
    }
    if (!WIFEXITED(status))
    {
        return GATE_RESULT_INVALIDSTATE;
    }
    if (exitcode)
    {
        *exitcode = WEXITSTATUS(status);
    }
    *handle = GATE_PROCESS_HANDLE_INVALID;
    return GATE_RESULT_OK;
#else
    result = waitid(P_PID, pid, &si, WEXITED | WNOWAIT | WNOHANG);
    if (result != 0)
    {
        return GATE_RESULT_NOTAVAILABLE;
    }
    if (si.si_pid != pid)
    {
        return GATE_RESULT_NOTAVAILABLE;
    }
    if (exitcode)
    {
        *exitcode = si.si_status;
    }
    return GATE_RESULT_OK;
#endif
}

gate_result_t gate_process_wait(gate_process_handle_t* handle, gate_uint32_t timeoutms)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    pid_t pid;
    siginfo_t si;
    int result;
    int status;
    gate_timecounter_t tcbegin, tcnow;
    gate_int64_t timediff;
    gate_int64_t timeoutus;
    gate_uint32_t sleepcounter;

    if (!handle || (*handle == GATE_PROCESS_HANDLE_INVALID))
    {
        return GATE_RESULT_INVALIDSTATE;
    }

    pid = (pid_t)(gate_intptr_t)*handle;

    if (timeoutms == GATE_PROCESS_WAIT_INFINITE)
    {
#if defined(GATE_SYS_OPENBSD)
        result = waitpid(pid, &status, 0);
        *handle = GATE_PROCESS_HANDLE_INVALID;
#else
        result = waitid(P_PID, pid, &si, WEXITED | WNOWAIT);
#endif
        if (result == 0)
        {
            ret = GATE_RESULT_OK;
        }
        else
        {
            gate_posix_errno(&ret);
        }
    }
    else
    {
        if (GATE_SUCCEEDED(gate_timecounter_now(&tcbegin)))
        {
            ret = GATE_RESULT_TIMEOUT;
            sleepcounter = 0;
            timeoutus = (gate_int64_t)timeoutms * 1000LL;
            do
            {
#if defined(GATE_SYS_OPENBSD)
                result = waitpid(pid, &status, WNOHANG);
                *handle = GATE_PROCESS_HANDLE_INVALID;
#else
                result = waitid(P_PID, pid, &si, WEXITED | WNOHANG | WNOWAIT);
#endif
                if (result == 0)
                {
                    if (si.si_pid == pid)
                    {
                        if ((si.si_code == CLD_KILLED) || (si.si_code == CLD_EXITED))
                        {
                            ret = GATE_RESULT_OK;
                            break;
                        }
                    }
                }

                {
                    /* reduce long-time polling */
                    gate_thread_sleep((sleepcounter));
                    if (sleepcounter < 100)
                    {
                        ++sleepcounter;
                    }
                }

                if (GATE_FAILED(gate_timecounter_now(&tcnow)))
                {
                    break;
                }
                timediff = gate_timecounter_diff(tcnow, tcbegin);
            } while (timediff < timeoutus);
        }
    }
    return ret;
}
gate_result_t gate_process_wait_pid(gate_process_id_t pid, gate_uint32_t timeoutms)
{
    return GATE_RESULT_NOTIMPLEMENTED;
}
gate_result_t gate_process_terminate(gate_process_handle_t* handle, gate_bool_t system_request)
{
    gate_process_id_t pid;
    if (!handle || (*handle == GATE_PROCESS_HANDLE_INVALID))
    {
        return GATE_RESULT_INVALIDSTATE;
    }
    pid = (gate_process_id_t)(gate_intptr_t)*handle;
    return gate_process_terminate_pid(pid, system_request);
}
gate_result_t gate_process_terminate_pid(gate_process_id_t pid, gate_bool_t system_request)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    pid_t proc_id = (pid_t)pid;
    if (-1 == kill(proc_id, system_request ? SIGTERM : SIGINT))
    {
        gate_posix_errno(&ret);
    }
    else
    {
        ret = GATE_RESULT_OK;
    }
    return ret;
}
gate_result_t gate_process_kill(gate_process_handle_t* handle)
{
    gate_process_id_t pid;
    if (!handle || (*handle == GATE_PROCESS_HANDLE_INVALID))
    {
        return GATE_RESULT_INVALIDSTATE;
    }
    pid = (gate_process_id_t)(gate_intptr_t)*handle;
    return gate_process_kill_pid(pid);
}
gate_result_t gate_process_kill_pid(gate_process_id_t pid)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    pid_t proc_id = (pid_t)pid;
    if (-1 == kill(proc_id, SIGKILL))
    {
        gate_posix_errno(&ret);
    }
    else
    {
        ret = GATE_RESULT_OK;
    }
    return ret;
}
gate_result_t gate_process_suspend(gate_process_handle_t* handle)
{
    gate_process_id_t pid;
    if (!handle || (*handle == GATE_PROCESS_HANDLE_INVALID))
    {
        return GATE_RESULT_INVALIDSTATE;
    }
    pid = (gate_process_id_t)(gate_intptr_t)*handle;
    return gate_process_suspend_pid(pid);
}
gate_result_t gate_process_suspend_pid(gate_process_id_t pid)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    pid_t proc_id = (pid_t)pid;
    if (-1 == kill(proc_id, SIGSTOP))
    {
        gate_posix_errno(&ret);
    }
    else
    {
        ret = GATE_RESULT_OK;
    }
    return ret;
}
gate_result_t gate_process_resume(gate_process_handle_t* handle)
{
    gate_process_id_t pid;
    if (!handle || (*handle == GATE_PROCESS_HANDLE_INVALID))
    {
        return GATE_RESULT_INVALIDSTATE;
    }
    pid = (gate_process_id_t)(gate_intptr_t)*handle;
    return gate_process_resume_pid(pid);
}
gate_result_t gate_process_resume_pid(gate_process_id_t pid)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    pid_t proc_id = (pid_t)pid;
    if (-1 == kill(proc_id, SIGCONT))
    {
        gate_posix_errno(&ret);
    }
    else
    {
        ret = GATE_RESULT_OK;
    }
    return ret;
}

#endif /* GATE_SYS_POSIX */