Cppcheck report - GATE C/C++ Framework: gate/processes.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_WIN16)
#   define GATE_PROCESSES_WINTASK_IMPL 1
#elif defined(GATE_SYS_WIN)
#   define GATE_PROCESSES_WINAPI_IMPL 1
#elif defined(GATE_SYS_WASM)
#   define GATE_PROCESSES_WASM_IMPL 1
#elif defined(GATE_SYS_BEOS)
#   define GATE_PROCESSES_BEOS_IMPL 1
#elif defined(GATE_SYS_POSIX)
#   define GATE_PROCESSES_POSIX_IMPL 1
#elif defined(GATE_SYS_EFI)
#   define GATE_PROCESSES_EFI_IMPL 1
#elif defined(GATE_SYS_DOS)
#   define GATE_PROCESSES_DOS_IMPL 1
#else
#   define GATE_PROCESSES_NOIMPL 1
#endif


gate_size_t gate_process_print_pid(gate_process_id_t pid, char* text, gate_size_t textlen)
{
    return gate_str_print_int64(text, textlen, pid);
}
gate_size_t gate_process_parse_pid(char const* text, gate_size_t textlen, gate_process_id_t* pid)
{
    return gate_str_parse_int64(text, textlen, pid);
}

gate_result_t gate_process_run(
    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_stream_t* output, int* exit_code
)
{
    gate_result_t ret;
    gate_process_handle_t handle = NULL;
    gate_process_stream_t* proc_stream = NULL;
    gate_process_stream_t** ptr_stream = (output == NULL) ? NULL : &proc_stream;
    char buffer[GATE_MAX_COPYBUFFER_LENGTH];
    gate_size_t used;
    gate_size_t written;

    do
    {
        ret = gate_process_start(executablepath, args, argcount, workdir, envvars, envvarcount, flags, &handle, NULL, ptr_stream);
        GATE_BREAK_IF_FAILED(ret);

        if ((ptr_stream != NULL) && (*ptr_stream != NULL))
        {
            while (GATE_SUCCEEDED(ret))
            {
                ret = gate_stream_read(*ptr_stream, buffer, sizeof(buffer), &used);
                GATE_BREAK_IF_FAILED(ret);
                if (used == 0)
                {
                    break;
                }
                ret = gate_stream_write_block(output, buffer, used, &written);
            }

            if (GATE_FAILED(ret))
            {
                ret = gate_process_kill(&handle);
            }

            if (GATE_SUCCEEDED(ret) && (exit_code != NULL))
            {
                ret = gate_process_get_exitcode(&handle, exit_code);
                if (ret == GATE_RESULT_INVALIDSTATE)
                {
                    ret = gate_process_wait(&handle, GATE_PROCESS_WAIT_INFINITE);<--- Variable 'ret' is reassigned a value before the old one has been used.
                    ret = gate_process_get_exitcode(&handle, exit_code);<--- Variable 'ret' is reassigned a value before the old one has been used.
                }
            }
        }
    } while (0);

    if (ptr_stream && (*ptr_stream))
    {
        gate_object_release(*ptr_stream);
    }

    if (handle != NULL)
    {
        gate_process_close(&handle);
    }
    return ret;
}








#if defined(GATE_PROCESSES_WASM_IMPL)

#include "gate/platform/wasm/wasm_gate.h"
#include <stdlib.h>

gate_result_t gate_process_get_id(gate_process_id_t* pid)
{
    *pid = 1;
    return GATE_RESULT_OK;
}
void gate_process_quit(int exitcode)
{
    exit(exitcode);
}

gate_result_t gate_process_enum(gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    return GATE_RESULT_OK;
}
gate_result_t gate_process_getinfo(gate_process_infobuffer_t* dest_buffer, gate_process_id_t proc_id, gate_enumint_t flags)
{
    return GATE_RESULT_NOTSUPPORTED;
}
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_RESULT_NOTSUPPORTED;
}
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)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_close(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_get_exitcode(gate_process_handle_t* handle, int* exitcode)
{
    return GATE_RESULT_NOTSUPPORTED;
}

gate_result_t gate_process_wait(gate_process_handle_t* handle, gate_uint32_t timeoutms)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_wait_pid(gate_process_id_t pid, gate_uint32_t timeoutms)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_terminate(gate_process_handle_t* handle, gate_bool_t system_request)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_terminate_pid(gate_process_id_t pid, gate_bool_t system_request)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_kill(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_kill_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_suspend(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_suspend_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_resume(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_resume_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}

#endif /* GATE_PROCESSES_WASM_IMPL */



#if defined(GATE_PROCESSES_BEOS_IMPL)

#include <kernel/OS.h>
#include <support/SupportDefs.h>

#include <stdlib.h>

gate_result_t gate_process_get_id(gate_process_id_t* pid)
{
    thread_id tid = find_thread(NULL);
    thread_info info;
    status_t status = get_thread_info(tid, &info);
    if (status != B_OK)
    {
        return GATE_RESULT_FAILED;
    }
    if (pid)
    {
        *pid = (gate_process_id_t)info.team;
    }
    return GATE_RESULT_OK;
}
void gate_process_quit(int exitcode)
{
    exit(exitcode);
}

gate_result_t gate_process_enum(gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    return GATE_RESULT_OK;
}
gate_result_t gate_process_getinfo(gate_process_infobuffer_t* dest_buffer, gate_process_id_t proc_id, gate_enumint_t flags)
{
    return GATE_RESULT_NOTSUPPORTED;
}
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_RESULT_NOTSUPPORTED;
}
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)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_close(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_get_exitcode(gate_process_handle_t* handle, int* exitcode)
{
    return GATE_RESULT_NOTSUPPORTED;
}

gate_result_t gate_process_wait(gate_process_handle_t* handle, gate_uint32_t timeoutms)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_wait_pid(gate_process_id_t pid, gate_uint32_t timeoutms)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_terminate(gate_process_handle_t* handle, gate_bool_t system_request)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_terminate_pid(gate_process_id_t pid, gate_bool_t system_request)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_kill(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_kill_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_suspend(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_suspend_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_resume(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_resume_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}

#endif /* GATE_PROCESSES_BEOS_IMPL */



#if defined(GATE_PROCESSES_NOIMPL)

#include <stdlib.h>

gate_result_t gate_process_get_id(gate_process_id_t* pid)
{
    *pid = 1;
    return GATE_RESULT_OK;
}
void gate_process_quit(int exitcode)
{
    exit(exitcode);
}

gate_result_t gate_process_enum(gate_process_enum_callback_t callback, void* userparam, gate_enumint_t flags)
{
    return GATE_RESULT_OK;
}
gate_result_t gate_process_getinfo(gate_process_infobuffer_t* dest_buffer, gate_process_id_t proc_id, gate_enumint_t flags)
{
    return GATE_RESULT_NOTSUPPORTED;
}
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_RESULT_NOTSUPPORTED;
}
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)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_close(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_get_exitcode(gate_process_handle_t* handle, int* exitcode)
{
    return GATE_RESULT_NOTSUPPORTED;
}

gate_result_t gate_process_wait(gate_process_handle_t* handle, gate_uint32_t timeoutms)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_wait_pid(gate_process_id_t pid, gate_uint32_t timeoutms)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_terminate(gate_process_handle_t* handle, gate_bool_t system_request)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_terminate_pid(gate_process_id_t pid, gate_bool_t system_request)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_kill(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_kill_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_suspend(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_suspend_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_resume(gate_process_handle_t* handle)
{
    return GATE_RESULT_NOTSUPPORTED;
}
gate_result_t gate_process_resume_pid(gate_process_id_t pid)
{
    return GATE_RESULT_NOTSUPPORTED;
}

#endif /* GATE_PROCESSES_NOIMPL */