Cppcheck report - GATE C/C++ Framework: apps/contools/gatecli/unit_file.c

#include "unit_file.h"

#include "gate/strings.h"
#include "gate/results.h"
#include "gate/files.h"
#include "gate/environments.h"
#include "gate/utilities.h"
#include "gate/encode/sha256hash.h"
#include "gate/debugging.h"

/***************
 *  file copy  *
 ***************/

typedef struct unit_file_copy_class
{
    gate_string_t source;
    gate_string_t dest;
    gate_bool_t overwrite;
} unit_file_copy_t;

static unit_file_copy_t file_copy_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_copy_params[] = {
    { "--source",		GATE_TYPE_STRING,	&file_copy_params.source, false, "Source file to be copied" },
    { "--dest",			GATE_TYPE_STRING,	&file_copy_params.dest, false, "Destination file path to receive copied data" },
    { "--overwrite",	GATE_TYPE_BOOL,	&file_copy_params.overwrite, true, "Overwrites destination file if it already exists" }
};

static gate_result_t unit_file_copy(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_uint32_t copy_flags = 0;
    if (file_copy_params.overwrite)
    {
        copy_flags |= GATE_FILE_COPY_OVERWRITE;
    }
    ret = gate_file_copy(&file_copy_params.source, &file_copy_params.dest, copy_flags);
    if (GATE_FAILED(ret))
    {
        gate_console_println_err(stream, gate_result_text(ret));
    }
    return ret;
}


/****************
 *  file xcopy  *
 ****************/

typedef struct unit_file_xcopy_class
{
    gate_string_t	source;
    gate_string_t	sourcelist;
    gate_string_t	dest;
    gate_bool_t		overwrite;
    gate_bool_t		ignore_errors;
    gate_bool_t		skip_existing;
    gate_bool_t		skip_newer;
} unit_file_xcopy_t;

static unit_file_xcopy_t file_xcopy_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_xcopy_params[] = {
    { "--source",			GATE_TYPE_STRING,	&file_xcopy_params.source, false, "Path to source to be copied" },
    { "--sourcelist",		GATE_TYPE_STRING,	&file_xcopy_params.sourcelist, false, "File containing a list of sources to be copied" },
    { "--dest",				GATE_TYPE_STRING,	&file_xcopy_params.dest, false, "Path to destination directory" },
    { "--overwrite",		GATE_TYPE_BOOL,		&file_xcopy_params.overwrite, true, "Overwrites already existing destination files" },
    { "--ignore-errors",	GATE_TYPE_BOOL,		&file_xcopy_params.ignore_errors, true, "Continues if copying a single file failes" },
    { "--skip-existing",	GATE_TYPE_BOOL,		&file_xcopy_params.skip_existing, true, "Skips file if destination is already existing" },
    { "--skip-newer",		GATE_TYPE_BOOL,		&file_xcopy_params.skip_newer, true, "Skips file if already existing destination is newer than source modification date" }
};

struct unit_file_xcopy_find_cb
{
    gate_string_t const* source_path;
    gate_string_t const* dest_path;
    gate_map_t* mapping;
};

static gate_bool_t unit_file_xcopy_find_sources_cb(gate_file_entry_t const* entry, void* userparam)
{
    gate_bool_t ret = true;
    struct unit_file_xcopy_find_cb* params = (struct unit_file_xcopy_find_cb*)userparam;
    gate_string_t source_file = GATE_STRING_INIT_EMPTY;
    gate_string_t dest_file = GATE_STRING_INIT_EMPTY;
    gate_string_t sub_path = GATE_STRING_INIT_EMPTY;

    do
    {
        if (NULL == gate_string_create(&source_file, entry->path, gate_str_length(entry->path)))
        {
            break;
        }
        if (NULL == gate_string_substr(&sub_path, &source_file, gate_string_length(params->source_path), GATE_STR_NPOS))
        {
            break;
        }
        if (NULL == gate_file_build_path_string(&dest_file, params->dest_path, &sub_path))
        {
            break;
        }
        gate_util_stringmap_add_string(params->mapping, &source_file, &dest_file);
    } while (0);

    gate_string_release(&source_file);
    gate_string_release(&dest_file);
    gate_string_release(&sub_path);

    return ret;
}


static gate_result_t unit_file_xcopy_find_sources(gate_string_t const* source_path, gate_string_t const* dest_path, gate_map_t* mapping)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    struct unit_file_xcopy_find_cb params = GATE_INIT_EMPTY;
    gate_file_filter_t filter = GATE_INIT_EMPTY;

    do
    {
        filter.recursive = true;

        params.source_path = source_path;
        params.dest_path = dest_path;
        params.mapping = mapping;

        ret = gate_file_find(source_path, &filter, &unit_file_xcopy_find_sources_cb, &params);

    } while (0);

    return ret;
}

static gate_result_t unit_file_xcopy_load_sourcelist(gate_string_t const* list_file, gate_string_t const* dest_path, gate_map_t* mapping)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_controlstream_t* stream = NULL;
    char buffer[GATE_MAX_FILEPATH_LENGTH];
    gate_size_t buffer_used;
    gate_string_t source_path = GATE_STRING_INIT_EMPTY;
    gate_string_t source_file_name = GATE_STRING_INIT_EMPTY;
    gate_string_t dest_file = GATE_STRING_INIT_EMPTY;

    do
    {
        ret = gate_file_openstream(list_file, GATE_STREAM_OPEN_READ, &stream);
        GATE_BREAK_IF_FAILED(ret);

        while (GATE_SUCCEEDED(ret = gate_stream_read_line((gate_stream_t*)stream, buffer, sizeof(buffer), &buffer_used)))
        {
            if (buffer_used == 0)
            {
                /* end of stream reached */
                break;
            }
            if (NULL != gate_string_create(&source_path, buffer, buffer_used))
            {
                gate_string_trim(&source_path, &source_path);
                if (!gate_string_is_empty(&source_path))
                {
                    if (GATE_SUCCEEDED(gate_file_split_path(&source_path, NULL, &source_file_name)))
                    {
                        if (NULL != gate_file_build_path_string(&dest_file, dest_path, &source_file_name))
                        {
                            gate_util_stringmap_add_string(mapping, &source_path, &dest_file);
                            gate_string_release(&dest_file);
                        }
                        gate_string_release(&source_file_name);
                    }
                }
                gate_string_release(&source_path);
            }
        }
    } while (0);
    if (stream != NULL)
    {
        gate_object_release(stream);
    }
    return ret;
}

static gate_bool_t unti_file_xcopy_callback(char const* source_path, char const* dest_path, gate_result_t result, void* user_param)
{
    gate_console_t* con = (gate_console_t*)user_param;
    gate_stream_t* stream = (gate_stream_t*)con;

    if (GATE_SUCCEEDED(result))
    {
        gate_stream_print_cstr(stream, source_path);
        gate_stream_print_cstr(stream, " ==> ");
        gate_stream_println_cstr(stream, dest_path);
    }
    else
    {
        gate_console_print_err(con, "Error '");
        gate_console_print_err(con, gate_result_text(result));
        gate_console_print_err(con, " copying \"");
        gate_console_print_err(con, source_path);
        gate_console_print_err(con, "\" ==> \"");
        gate_console_print_err(con, dest_path);
        gate_console_println_err(con, "\"");
    }
    return true;
}

static gate_result_t unit_file_xcopy(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_uint32_t copy_flags = 0;

    gate_map_t copy_mapping = GATE_INIT_EMPTY;

    do
    {
        if (file_xcopy_params.overwrite)
        {
            copy_flags |= GATE_FILE_COPY_OVERWRITE;
        }
        if (file_xcopy_params.ignore_errors)
        {
            copy_flags |= GATE_FILE_COPY_IGNORE_ERROR;
        }
        if (file_xcopy_params.skip_existing)
        {
            copy_flags |= GATE_FILE_COPY_SKIP_EXISTING;
        }
        if (file_xcopy_params.skip_newer)
        {
            copy_flags |= GATE_FILE_COPY_SKIP_NEWER;
        }

        if (NULL == gate_util_stringmap_create(&copy_mapping))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        if (!gate_string_is_empty(&file_xcopy_params.source))
        {
            ret = unit_file_xcopy_find_sources(&file_xcopy_params.source, &file_xcopy_params.dest, &copy_mapping);
            GATE_BREAK_IF_FAILED(ret);
        }
        if (!gate_string_is_empty(&file_xcopy_params.sourcelist))
        {
            ret = unit_file_xcopy_load_sourcelist(&file_xcopy_params.sourcelist, &file_xcopy_params.dest, &copy_mapping);
            GATE_BREAK_IF_FAILED(ret);
        }

        ret = gate_file_copy_list(&copy_mapping, copy_flags, &unti_file_xcopy_callback, (void*)stream);<--- Variable 'ret' is reassigned a value before the old one has been used.

    } while (0);

    gate_map_destroy(&copy_mapping);

    if (file_copy_params.overwrite)
    {
        flags |= GATE_FILE_COPY_OVERWRITE;
    }
    ret = gate_file_copy(&file_copy_params.source, &file_copy_params.dest, flags);<--- Variable 'ret' is reassigned a value before the old one has been used.
    if (GATE_FAILED(ret))
    {
        gate_console_println_err(stream, gate_result_text(ret));
    }
    return ret;
}




/***************
 *  file move  *
 ***************/

typedef struct unit_file_move_class
{
    gate_string_t source;
    gate_string_t dest;
} unit_file_move_t;

static unit_file_move_t file_move_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_move_params[] = {
    { "--source",	GATE_TYPE_STRING,	&file_move_params.source, false },
    { "--dest",		GATE_TYPE_STRING,	&file_move_params.dest, false }
};

static gate_result_t unit_file_move(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;

    ret = gate_file_move(&file_move_params.source, &file_move_params.dest);

    return ret;
}





/*****************
 *  file delete  *
 *****************/

typedef struct unit_file_delete_class
{
    gate_string_t file;
} unit_file_delete_t;

static unit_file_delete_t file_delete_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_delete_params[] = {
    { "--file",		GATE_TYPE_STRING,	&file_delete_params.file, false }
};

static gate_result_t unit_file_delete(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;

    ret = gate_file_delete(&file_delete_params.file);

    return ret;
}






/***************
 *  file link  *
 ***************/

typedef struct unit_file_link_class
{
    gate_string_t source;
    gate_string_t dest;
} unit_file_link_t;

static unit_file_link_t file_link_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_link_params[] = {
    { "--source",	GATE_TYPE_STRING,	&file_link_params.source, false },
    { "--dest",		GATE_TYPE_STRING,	&file_link_params.dest, false }
};

static gate_result_t unit_file_link(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;

    ret = gate_file_create_link(&file_link_params.source, &file_link_params.dest);

    return ret;
}



/********************
 *  file get-owner  *
 ********************/

typedef struct unit_file_getowner_class
{
    gate_string_t source;
} unit_file_getowner_t;

static unit_file_link_t file_getowner_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_getowner_params[] = {
    { "--source",	GATE_TYPE_STRING,	&file_getowner_params.source, false },
};

static gate_result_t unit_file_getowner(gate_console_t* con, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_stream_t* stream = (gate_stream_t*)con;
    gate_uint32_t owner_id = 0;
    gate_string_t owner_name = GATE_STRING_INIT_EMPTY;

    ret = gate_file_get_owner(&file_getowner_params.source, &owner_id, &owner_name);
    if (GATE_SUCCEEDED(ret))
    {
        gate_stream_print(stream,
            GATE_PRINT_CSTR, "ID:\t",
            GATE_PRINT_UI32, owner_id,
            GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, "Name:\t",
            GATE_PRINT_STRING, &owner_name,
            GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
    }

    return ret;
}





/*******************
 *  file readlink  *
 *******************/

typedef struct unit_file_readlink_class
{
    gate_string_t file;
} unit_file_readlink_t;

static unit_file_readlink_t file_readlink_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_readlink_params[] = {
    { "--file",	GATE_TYPE_STRING,	&file_readlink_params.file, false },
};

static gate_result_t unit_file_readlink(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_string_t realpath;

    ret = gate_file_read_link(&file_readlink_params.file, &realpath);
    if (GATE_FAILED(ret))
    {
        gate_console_println_err(stream, "Failed to read link target");
    }
    else
    {
        gate_stream_print_string((gate_stream_t*)stream, &realpath);
    }

    return ret;
}



/***************
 *  file list  *
 ***************/

typedef struct unit_file_list_params_class
{
    gate_string_t path;
    gate_bool_t   recursive;
    gate_string_t pattern;
    gate_uint64_t from_size;
    gate_uint64_t to_size;
    gate_string_t from_modified;
    gate_string_t to_modified;
    gate_bool_t	  show_info;
} unit_file_list_params_t;

static unit_file_list_params_t file_list_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_list_params[] = {
    { "--path",			GATE_TYPE_STRING,	&file_list_params.path, true },
    { "--recursive",	GATE_TYPE_BOOL,	&file_list_params.recursive, true },
    { "--pattern",		GATE_TYPE_STRING,	&file_list_params.pattern, true },
    { "--from-size",	GATE_TYPE_I64,		&file_list_params.from_size, true },
    { "--to-size",		GATE_TYPE_I64,		&file_list_params.to_size, true },
    { "--from-modified",GATE_TYPE_STRING,	&file_list_params.from_modified, true },
    { "--to-modified",	GATE_TYPE_STRING,	&file_list_params.to_modified, true },
    { "--info",			GATE_TYPE_BOOL,	&file_list_params.show_info, true }
};

static gate_bool_t unit_file_list_cb(gate_file_entry_t const* entry, void* userparam)
{
    gate_console_t* console = (gate_console_t*)userparam;
    gate_stream_t* stream = (gate_stream_t*)console;

    gate_stream_print(stream,
        GATE_PRINT_CSTR, entry->path, GATE_PRINT_NEWLINE,
        GATE_PRINT_END);

    return true;
}

static gate_uint64_t dir_counter = 0;
static gate_uint64_t file_counter = 0;
static gate_uint64_t file_size_sum = 0;

static gate_bool_t unit_file_list_info_cb(gate_file_entry_t const* entry, void* userparam)
{
    gate_console_t* console = (gate_console_t*)userparam;
    gate_stream_t* stream = (gate_stream_t*)console;
    gate_time_t modified = { 0, 0 };
    char modified_buffer[64] = GATE_INIT_EMPTY;
    gate_size_t modified_size = sizeof(modified_buffer);
    char size_buffer[64] = GATE_INIT_EMPTY;
    gate_size_t size_size = sizeof(size_buffer);


    gate_time_from_timestamp(entry->props.time_modified, &modified);
    gate_time_to_string(&modified, NULL, modified_buffer, &modified_size);

    gate_stream_print(stream,
        GATE_PRINT_CSTR, entry->path, GATE_PRINT_NEWLINE,
        GATE_PRINT_CSTR, "\tName: ", GATE_PRINT_CSTR, entry->name, GATE_PRINT_NEWLINE,
        GATE_PRINT_END);

    if (GATE_FLAG_ENABLED(entry->props.attribs, GATE_FILEENTRY_ATTRIB_LINK))
    {
        gate_stream_print(stream,
            GATE_PRINT_CSTR, "\tType: Link", GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
    }
    if (GATE_FLAG_ENABLED(entry->props.attribs, GATE_FILEENTRY_ATTRIB_DIRECTORY))
    {
        ++dir_counter;
        gate_stream_print(stream,
            GATE_PRINT_CSTR, "\tType: Directory", GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
    }
    else
    {
        ++file_counter;
        file_size_sum += entry->props.size;
        gate_util_print_byte_size(entry->props.size, size_buffer, size_size);
        gate_stream_print(stream,
            GATE_PRINT_CSTR, "\tSize: ", GATE_PRINT_CSTR, size_buffer,
            GATE_PRINT_CSTR, " (",
            GATE_PRINT_UI64, entry->props.size,
            GATE_PRINT_CSTR, ")", GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
    }

    gate_stream_print(stream,
        GATE_PRINT_CSTR, "\tModified: ", GATE_PRINT_CSTR, modified_buffer, GATE_PRINT_NEWLINE,
        GATE_PRINT_END);

    return true;
}

static gate_result_t unit_file_list(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_file_filter_t filter;
    gate_timestamp_t from_modified = 0;
    gate_timestamp_t to_modified = 0;
    gate_time_t tm_from, tm_to;
    gate_char8_t total_size_buffer[64] = GATE_INIT_EMPTY;
    gate_size_t total_size_length = sizeof(total_size_buffer);

    if (gate_string_is_empty(&file_list_params.path))
    {
        gate_env_get_workpath(&file_list_params.path);
    }

    if (!gate_string_is_empty(&file_list_params.from_modified))
    {
        ret = gate_time_parse_string(file_list_params.from_modified.str, file_list_params.from_modified.length, &tm_from);
        if (GATE_SUCCEEDED(ret))
        {
            from_modified = tm_from.timestamp;
        }
    }
    if (!gate_string_is_empty(&file_list_params.to_modified))
    {
        ret = gate_time_parse_string(file_list_params.to_modified.str, file_list_params.to_modified.length, &tm_to);
        if (GATE_SUCCEEDED(ret))
        {
            to_modified = tm_to.timestamp;
        }
    }

    gate_mem_clear(&filter, sizeof(filter));

    filter.pattern = file_list_params.pattern;
    filter.from_size = file_list_params.from_size;
    filter.to_size = file_list_params.to_size;
    filter.recursive = file_list_params.recursive;
    filter.from_modified = from_modified;
    filter.to_modified = to_modified;

    if (file_list_params.show_info)
    {
        dir_counter = 0;
        file_counter = 0;
        file_size_sum = 0;
        ret = gate_file_find(&file_list_params.path, &filter, &unit_file_list_info_cb, stream);

        gate_util_print_byte_size(file_size_sum, total_size_buffer, total_size_length);

        gate_stream_print((gate_stream_t*)stream, GATE_PRINT_NEWLINE,
            GATE_PRINT_UI64, dir_counter, GATE_PRINT_CSTR, " directory entries found", GATE_PRINT_NEWLINE,
            GATE_PRINT_UI64, file_counter, GATE_PRINT_CSTR, " file entries found", GATE_PRINT_NEWLINE,
            GATE_PRINT_CSTR, total_size_buffer, GATE_PRINT_CSTR, " (", GATE_PRINT_UI64, file_size_sum,
            GATE_PRINT_CSTR, ") in all found file entries", GATE_PRINT_NEWLINE,
            GATE_PRINT_END);
    }
    else
    {
        ret = gate_file_find(&file_list_params.path, &filter, &unit_file_list_cb, stream);
    }
    return ret;
}


/****************
 *  file qlist  *
 ****************/

typedef struct unit_file_qlist_params_class
{
    gate_string_t path;
} unit_file_qlist_params_t;

static unit_file_qlist_params_t file_qlist_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_qlist_params[] = {
    { "--path",			GATE_TYPE_STRING,	&file_qlist_params.path, true, "Path of directory to be listed" }
};


static gate_result_t unit_file_qlist(gate_console_t* con, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_file_dirreader_t reader;
    char path[GATE_MAX_FILEPATH_LENGTH];
<--- The scope of the variable 'path' can be reduced. [+]
The scope of the variable 'path' 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_size_t path_len;
    gate_stream_t* stream = (gate_stream_t*)con;

    ret = gate_file_dir_open(&file_qlist_params.path, &reader);
    if (GATE_SUCCEEDED(ret))
    {
        while (0 < (path_len = gate_file_dir_read(&reader, path, sizeof(path), false)))
        {
            path[path_len] = 0;
            gate_stream_println_cstr(stream, path);
        }
        gate_file_dir_close(&reader);
    }
    else
    {
        gate_console_print_err(con, "Failed to open directory, #");
        gate_console_print_err_num(con, ret);
        gate_console_println_err(con, NULL);
        gate_console_println_err(con, gate_result_text(ret));
    }
    return ret;
}


/***********************
 *  file list-volumes  *
 ***********************/

static gate_bool_t unit_file_listvolumes_callback(gate_file_entry_t const* entry, void* userparam)
{
    gate_stream_t* stream = (gate_stream_t*)userparam;
    gate_stream_print(stream,
        GATE_PRINT_CSTR, entry->path,
        GATE_PRINT_NEWLINE,
        GATE_PRINT_END);
    return true;
}

static gate_result_t unit_file_listvolumes(gate_console_t* con, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_stream_t* stream = (gate_stream_t*)con;

    ret = gate_file_root_list(&unit_file_listvolumes_callback, stream);

    return ret;
}





/******************
*  file set-date  *
*******************/

typedef struct unit_file_setdate_class
{
    gate_string_t file;
    gate_string_t date;
    gate_bool_t modification;
    gate_bool_t creation;
    gate_bool_t access;
} unit_file_setdate_t;

static unit_file_setdate_t file_setdate_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_setdate_params[] = {
    { "--file",			GATE_TYPE_STRING,	&file_setdate_params.file, false, "Path to the file to be changed" },
    { "--date",			GATE_TYPE_STRING,	&file_setdate_params.date, false, "Defines a date in format yyyy-mm-ddThh:mm:ss" },
    { "--modification",	GATE_TYPE_BOOL,	&file_setdate_params.modification, false, "Changes the modification time of a file" },
    { "--creation",		GATE_TYPE_BOOL,	&file_setdate_params.creation, false, "Changes the creation time of a file" },
    { "--access",		GATE_TYPE_BOOL,	&file_setdate_params.access, false, "Changes the access time of a file" }
};

static gate_result_t unit_file_setdate(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_time_t time = GATE_INIT_EMPTY;
    gate_timestamp_t* ptr_modification = NULL;
    gate_timestamp_t* ptr_creation = NULL;
    gate_timestamp_t* ptr_access = NULL;

    do
    {
        ret = gate_time_parse_string(file_setdate_params.date.str, file_setdate_params.date.length, &time);
        GATE_BREAK_IF_FAILED(ret);

        if (file_setdate_params.modification) ptr_modification = &time.timestamp;
        if (file_setdate_params.creation) ptr_creation = &time.timestamp;
        if (file_setdate_params.access) ptr_access = &time.timestamp;

        ret = gate_file_set_times(&file_setdate_params.file, ptr_modification, ptr_access, ptr_creation);
        if (GATE_FAILED(ret))
        {
            gate_console_print_err(stream, "Failed to update file date, Error code: ");
            gate_console_print_err_num(stream, ret);
            gate_console_print_err(stream, GATE_STR_NEWLINE);
        }

    } while (0);
    return ret;
}



/***************
 *  file find  *
 ***************/

typedef struct unit_file_find_class
{
    gate_string_t path;
    gate_string_t pattern;
    gate_string_t patternfile;
    gate_string_t resultfile;
} unit_file_find_t;

static unit_file_find_t file_find_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_find_params[] = {
    { "--path",			GATE_TYPE_STRING,	&file_find_params.path, true, "" },
    { "--pattern",		GATE_TYPE_STRING,	&file_find_params.pattern, true, "" },
    { "--patternfile",	GATE_TYPE_STRING,	&file_find_params.patternfile, true, "" },
    { "--resultfile",	GATE_TYPE_STRING,	&file_find_params.resultfile, true, "" }
};

struct unit_file_find_param
{
    gate_size_t			pattern_count;
    gate_arraylist_t	patterns;
    gate_set_t			used_patterns;
    gate_map_t			results;
};

static gate_bool_t unit_file_find_cb(gate_file_entry_t const* entry, void* userparam)
{
    struct unit_file_find_param* params = (struct unit_file_find_param*)userparam;
    gate_size_t ndx;
    gate_string_t const* ptr_pattern;
<--- The scope of the variable 'ptr_pattern' can be reduced. [+]
The scope of the variable 'ptr_pattern' 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_string_t test_file_name;

    for (ndx = 0; ndx != params->pattern_count; ++ndx)
    {
        ptr_pattern = (gate_string_t const*)gate_arraylist_get(params->patterns, ndx);
        if (ptr_pattern)
        {
            gate_string_create_static(&test_file_name, entry->name);

            if (gate_string_like(&test_file_name, ptr_pattern))
            {
                gate_util_stringmap_add(&params->results, entry->path, entry->name);
                gate_util_stringset_add_string(&params->used_patterns, ptr_pattern);
            }
            gate_string_release(&test_file_name);
        }
    }
    return true;
}

static gate_result_t unit_file_find(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    static gate_string_t current_dir = GATE_STRING_INIT_STATIC(".");
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_stream_t* ptr_stream = (gate_stream_t*)stream;
    struct unit_file_find_param search_params = GATE_INIT_EMPTY;
    gate_file_filter_t filter;
    gate_map_iterator_t map_iter;
    gate_string_t const* ptr_path;
    gate_string_t const* ptr_name;
<--- The scope of the variable 'ptr_name' can be reduced. [+]
The scope of the variable 'ptr_name' 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_set_t pattern_set = GATE_INIT_EMPTY;
    gate_set_iterator_t pattern_iter;
    gate_string_t const* ptr_str;
    gate_size_t ndx;

    do
    {
        gate_mem_clear(&search_params, sizeof(search_params));
        gate_mem_clear(&filter, sizeof(filter));
        filter.recursive = true;

        search_params.patterns = gate_util_stringarray_create();
        if (search_params.patterns == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        if (NULL == gate_util_stringmap_create(&search_params.results))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        if (NULL == gate_util_stringset_create(&search_params.used_patterns))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        if (!gate_string_is_empty(&file_find_params.patternfile))
        {
            ret = gate_file_get_content_lines(&file_find_params.patternfile, search_params.patterns);
            GATE_BREAK_IF_FAILED(ret);
        }
        if (!gate_string_is_empty(&file_find_params.pattern))
        {
            gate_util_stringarray_add(search_params.patterns, &file_find_params.pattern);
        }

        search_params.pattern_count = gate_arraylist_length(search_params.patterns);
        if (search_params.pattern_count == 0)
        {
            gate_console_println_err(stream, "Missing pattern argument");
            ret = GATE_RESULT_INVALIDARG;
            break;
        }

        ret = gate_file_find(gate_string_is_empty(&file_find_params.path) ? &current_dir : &file_find_params.path,
            &filter, &unit_file_find_cb, &search_params);
        GATE_BREAK_IF_FAILED(ret);

        map_iter = gate_map_first(&search_params.results);
        while (gate_map_iterator_valid(map_iter))
        {
            ptr_path = (gate_string_t const*)gate_map_iterator_key(map_iter);
            ptr_name = (gate_string_t const*)gate_map_iterator_value(map_iter);

            gate_stream_print_string(ptr_stream, ptr_path);
            gate_stream_println_cstr(ptr_stream, NULL);

            map_iter = gate_map_iterator_next(map_iter);
        }

        if (NULL != gate_set_create(&pattern_set, &gate_compare_string, sizeof(gate_string_t), &gate_string_copy_constructor, &gate_string_destructor))
        {
            for (ndx = 0; ndx != gate_arraylist_length(search_params.patterns); ++ndx)
            {
                gate_set_add(&pattern_set, gate_arraylist_get(search_params.patterns, ndx));
            }
            gate_set_remove_keys(&pattern_set, &search_params.used_patterns);

            if (gate_set_count(&pattern_set) != 0)
            {
                gate_console_println_err(stream, "*** Unmatched patterns ***");
                pattern_iter = gate_set_first(&pattern_set);
                while (gate_set_iterator_valid(pattern_iter))
                {
                    ptr_str = (gate_string_t const*)gate_map_iterator_key(pattern_iter);
                    gate_console_write_err(stream, ptr_str->str, ptr_str->length);
                    gate_console_println_err(stream, NULL);
                    pattern_iter = gate_set_iterator_next(pattern_iter);
                }
            }
        }

    } while (0);

    gate_arraylist_release(search_params.patterns);
    gate_set_destroy(&search_params.used_patterns);
    gate_map_destroy(&search_params.results);
    gate_set_destroy(&pattern_set);

    return ret;
}





/**************************
 *  file hashlist-create  *
 **************************/

typedef struct unit_file_hashlistcreate_class
{
    gate_string_t path;
    gate_string_t output;
    gate_bool_t dir_hash;
} unit_file_hashlistcreate_t;

static unit_file_hashlistcreate_t file_hashlistcreate_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_hashlistcreate_params[] = {
    { "--path",		GATE_TYPE_STRING,	&file_hashlistcreate_params.path, true, "Directory path where hashing starts" },
    { "--output",	GATE_TYPE_STRING,	&file_hashlistcreate_params.output, true, "Output file that stores all hashes" },
    { "--dir-hash",	GATE_TYPE_BOOL,		&file_hashlistcreate_params.dir_hash, true, "Generates for hashes for directories" }
};


typedef struct
{
    gate_result_t	internal_error;	/* stores internal error codes */
    gate_map_t* file_mapping;	/* map<string, string>: path -> hash */
    gate_stream_t* out_stream;		/* output streams that receives hash lines */

} unit_file_hashlistcreate_param_t;

static gate_result_t unit_file_hashlistcreate_print_hash(gate_stream_t* stream, gate_uint32_t attribs, gate_string_t const* file_path, gate_string_t const* file_hash)
{
    char type[2] = "?";
    if (GATE_FLAG_ENABLED(attribs, GATE_FILEENTRY_ATTRIB_DIRECTORY))
    {
        type[0] = 'D';	/* directory */
    }
    else if (GATE_FLAG_ENABLED(attribs, GATE_FILEENTRY_ATTRIB_DEVICE))
    {
        type[0] = 'S';	/* special */
    }
    else if (GATE_FLAG_ENABLED(attribs, GATE_FILEENTRY_ATTRIB_LINK))
    {
        type[0] = 'L';	/* link */
    }
    else
    {
        type[0] = 'F';	/* file */
    }

    return gate_stream_print(stream,
        GATE_PRINT_CSTR, type,
        GATE_PRINT_CSTR, ";",
        GATE_PRINT_STRING, file_hash,
        GATE_PRINT_CSTR, ";",
        GATE_PRINT_STRING, file_path,
        GATE_PRINT_NEWLINE,
        GATE_PRINT_END
    );
}

static gate_bool_t unit_file_hashlistcreate_cb(gate_file_entry_t const* entry, void* userparam)
{
    gate_bool_t ret = true;
    unit_file_hashlistcreate_param_t* param = (unit_file_hashlistcreate_param_t*)userparam;
    gate_result_t result;
    gate_file_t file_handle;
    gate_sha256_t hash;
    gate_string_t file_path = GATE_STRING_INIT_EMPTY;
    gate_string_t file_hash = GATE_STRING_INIT_EMPTY;
    gate_strbuilder_t builder;
    char textbuffer[GATE_MAX_FILEPATH_LENGTH];
    char readbuffer[GATE_MAX_COPYBUFFER_LENGTH];
    char szbuffer[20];
    gate_size_t bytes_received;
    gate_uint64_t file_size = 0;
    gate_bool_t continue_read = true;
    gate_sha256_result_t hash_result;

    do
    {
        if (GATE_FLAG_ENABLED(entry->props.attribs, GATE_FILEENTRY_ATTRIB_DIRECTORY))
        {
            break;
        }

        if (NULL == gate_string_create(&file_path, entry->path, gate_str_length(entry->path)))
        {
            param->internal_error = GATE_RESULT_OUTOFMEMORY;
            ret = false;
            break;
        }

        gate_strbuilder_create_static(&builder, textbuffer, sizeof(textbuffer) - 1, 0);

        result = gate_file_open(&file_path, GATE_STREAM_OPEN_READ, &file_handle);
        if (GATE_SUCCEEDED(result))
        {
            gate_sha256_init(&hash);

            while (continue_read)
            {
                result = gate_file_read(file_handle, readbuffer, sizeof(readbuffer), &bytes_received);
                if (GATE_FAILED(result))
                {
                    break;
                }
                if (bytes_received == 0)
                {
                    break;
                }
                file_size += bytes_received;
                gate_sha256_update(&hash, readbuffer, bytes_received);
            }
            gate_file_close(file_handle);
        }

        if (GATE_SUCCEEDED(result))
        {
            /* we have a file hash */
            gate_sha256_finish(&hash, &hash_result);
            gate_strbuilder_append_hex(&builder, hash_result.hash, sizeof(hash_result.hash), false);
        }
        else
        {
            /* file access has failed -> fill hashspace with '?' */
            file_size = entry->props.size;
            gate_strbuilder_append_chars(&builder, GATE_SHA256_RESULT_LENGTH * 2, '?');
        }
        gate_strbuilder_append_chars(&builder, 1, '-');

        bytes_received = gate_str_print_hex_uint64(szbuffer, sizeof(szbuffer), file_size, false);
        gate_strbuilder_append_text(&builder, szbuffer, bytes_received);

        if (NULL == gate_strbuilder_copy_to_string(&builder, &file_hash))
        {
            param->internal_error = GATE_RESULT_OUTOFMEMORY;
            ret = false;
            break;
        }

        if (param->file_mapping)
        {
            if (NULL == gate_util_stringmap_add_string(param->file_mapping, &file_path, &file_hash))
            {
                param->internal_error = GATE_RESULT_OUTOFMEMORY;
                ret = false;
                break;
            }
        }

        if (param->out_stream)
        {
            unit_file_hashlistcreate_print_hash(param->out_stream, false, &file_path, &file_hash);
        }
    } while (0);

    gate_string_release(&file_path);
    gate_string_release(&file_hash);


    return ret;
}

static gate_result_t unit_file_hashlistcreate(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    gate_result_t ret;
    gate_file_filter_t filter;
    gate_string_t start_path = GATE_STRING_INIT_EMPTY;
    unit_file_hashlistcreate_param_t fs_param;
    gate_map_t file_mapping = GATE_INIT_EMPTY;
    gate_controlstream_t* output = NULL;

    do
    {
        gate_mem_clear(&fs_param, sizeof(fs_param));
        fs_param.internal_error = GATE_RESULT_OK;

        if (file_hashlistcreate_params.dir_hash)
        {
            if (NULL == gate_util_stringmap_create(&file_mapping))
            {
                gate_console_print_err(stream, "Failed to allocate file hash mapping table");
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
            fs_param.file_mapping = &file_mapping;
        }

        if (gate_string_is_empty(&file_hashlistcreate_params.output))
        {
            fs_param.out_stream = (gate_stream_t*)stream;
        }
        else
        {
            ret = gate_file_openstream(&file_hashlistcreate_params.output, GATE_STREAM_OPEN_WRITE, &output);
            if (GATE_FAILED(ret))
            {
                gate_console_print_err(stream, "Failed to open output stream");
                break;
            }
            fs_param.out_stream = (gate_stream_t*)output;
        }


        gate_mem_clear(&filter, sizeof(filter));
        filter.recursive = true;

        if (gate_string_is_empty(&file_hashlistcreate_params.path))
        {
            ret = gate_env_get_workpath(&start_path);
            if (GATE_FAILED(ret))
            {
                gate_console_print_err(stream, "Failed to retrieve current working directory");
                break;
            }
        }
        else
        {
            if (NULL == gate_string_duplicate(&start_path, &file_hashlistcreate_params.path))
            {
                gate_console_print_err(stream, "Failed to allocate start directory");
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
        }

        ret = gate_file_find(&start_path, &filter, &unit_file_hashlistcreate_cb, &fs_param);
        if (GATE_FAILED(ret))
        {
            gate_console_print_err(stream, "Failed to search for files");
            break;
        }

        if (GATE_FAILED(fs_param.internal_error))
        {
            gate_console_print_err(stream, "Internal error during file iteration");
            ret = fs_param.internal_error;
            break;
        }

        ret = GATE_RESULT_OK;

    } while (0);

    gate_map_destroy(&file_mapping);
    gate_string_release(&start_path);
    if (output)
    {
        gate_object_release(output);
    }

    return ret;
}






/*********************
 *  file find-links  *
 *********************/

typedef struct unit_file_findlinks_class
{
    gate_string_t path;
    gate_bool_t recursive;
    gate_string_t resultfile;
} unit_file_findlinks_t;

static unit_file_findlinks_t file_findlinks_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_findlinks_params[] = {
    { "--path",			GATE_TYPE_STRING,	&file_findlinks_params.path, true, "" },
    { "--recursive",	GATE_TYPE_BOOL,		&file_findlinks_params.recursive, true, "" },
    { "--resultfile",	GATE_TYPE_STRING,	&file_findlinks_params.resultfile, true, "" }
};

static gate_bool_t unit_file_findlinks_cb(gate_file_entry_t const* entry, void* userparam)
{
    gate_map_t* mapping = (gate_map_t*)userparam;
    gate_string_t path = GATE_STRING_INIT_EMPTY;
    gate_string_t link_path = GATE_STRING_INIT_EMPTY;
    gate_result_t result;

    if (GATE_FLAG_ENABLED(entry->props.attribs, GATE_FILEENTRY_ATTRIB_LINK))
    {
        do
        {
            if (NULL == gate_string_create(&path, entry->path, gate_str_length(entry->path)))
            {
                break;
            }
            result = gate_file_read_link(&path, &link_path);
            if (GATE_FAILED(result))
            {
                gate_string_create_empty(&link_path);
            }
            gate_map_add(mapping, &path, &link_path);
        } while (0);
    }
    gate_string_release(&link_path);
    gate_string_release(&path);

    return true;
}

static gate_result_t unit_file_findlinks(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    static gate_string_t current_dir = GATE_STRING_INIT_STATIC(".");
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_stream_t* ptr_stream = (gate_stream_t*)stream;
    gate_map_t search_results = GATE_INIT_EMPTY;
    gate_file_filter_t filter;
    gate_map_iterator_t map_iter;
    gate_string_t const* ptr_path;
    gate_string_t const* ptr_link;

    do
    {
        gate_mem_clear(&filter, sizeof(filter));
        filter.recursive = file_findlinks_params.recursive;

        if (NULL == gate_util_stringmap_create(&search_results))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = gate_file_find(gate_string_is_empty(&file_findlinks_params.path) ? &current_dir : &file_findlinks_params.path,
            &filter, &unit_file_findlinks_cb, &search_results);
        GATE_BREAK_IF_FAILED(ret);

        map_iter = gate_map_first(&search_results);
        while (gate_map_iterator_valid(map_iter))
        {
            ptr_path = (gate_string_t const*)gate_map_iterator_key(map_iter);
            ptr_link = (gate_string_t const*)gate_map_iterator_value(map_iter);

            gate_stream_print_string(ptr_stream, ptr_path);
            gate_stream_print_cstr(ptr_stream, "\t");
            gate_stream_print_string(ptr_stream, ptr_link);
            gate_stream_println_cstr(ptr_stream, NULL);

            map_iter = gate_map_iterator_next(map_iter);
        }
    } while (0);

    gate_map_destroy(&search_results);

    return ret;
}





/*********************
 *  file remove-links  *
 *********************/

typedef struct unit_file_removelinks_class
{
    gate_string_t	path;
    gate_bool_t		dry_run;
} unit_file_removelinks_t;

static unit_file_removelinks_t file_removelinks_params = GATE_INIT_EMPTY;

static gatecli_paramter_t unit_file_removelinks_params[] = {
    { "--path",			GATE_TYPE_STRING,	&file_removelinks_params.path, true, "Path to folder where link search starts" },
    { "--dry-run",		GATE_TYPE_BOOL,		&file_removelinks_params.dry_run, true, "Apply no deletion, just show files" },
};

static gate_result_t get_links_in_directory(gate_string_t const* path, gate_arraylist_t linklist, gate_arraylist_t subdirs)
{
    gate_result_t result;
    gate_file_dirreader_t reader;
    char link_path[GATE_MAX_FILEPATH_LENGTH];
    gate_size_t used;
    gate_string_t link = GATE_STRING_INIT_EMPTY;
    gate_enumint_t attribs = 0;
    gate_enumint_t accessbits = 0;
    gate_string_t entry_name = GATE_STRING_INIT_EMPTY;
    static gate_string_t const dot_dir = GATE_STRING_INIT_STATIC(".");
    static gate_string_t const dotdot_dir = GATE_STRING_INIT_STATIC("..");

    do
    {
        result = gate_file_dir_open(path, &reader);
        if (GATE_FAILED(result))
        {
#if defined(GATE_DEBUG_MODE)
            gate_string_to_buffer(path, link_path, sizeof(link_path));
            GATE_DEBUG_TRACE("get_links_in_directory(): Failed to open directory");
            GATE_DEBUG_TRACE(link_path);
#endif
            break;
        }
        GATE_BREAK_IF_FAILED(result);

        while (0 != (used = gate_file_dir_read(&reader, link_path, sizeof(link_path), false)))
        {
            if (NULL != gate_string_create(&link, link_path, used))
            {
                result = gate_file_split_path(&link, NULL, &entry_name);
                if (GATE_SUCCEEDED(result))
                {
                    if (!gate_string_equals(&entry_name, &dot_dir) && !gate_string_equals(&entry_name, &dotdot_dir))
                    {
                        attribs = 0;
                        accessbits = 0;
                        result = gate_file_get_attributes(&link, &attribs, &accessbits);
                        if (GATE_SUCCEEDED(result))
                        {
                            if (GATE_FLAG_ENABLED(attribs, GATE_FILEENTRY_ATTRIB_LINK))
                            {
                                gate_arraylist_add(linklist, &link);
                            }
                            else if (GATE_FLAG_ENABLED(attribs, GATE_FILEENTRY_ATTRIB_DIRECTORY))
                            {
                                gate_arraylist_add(subdirs, &link);
                            }
                        }
                    }
                    gate_string_release(&entry_name);
                }
                gate_string_release(&link);
            }
        }
        gate_file_dir_close(&reader);
        result = GATE_RESULT_OK;
    } while (0);

    return result;
}

static gate_result_t unit_file_removelinks(gate_console_t* stream, char const* const* params, gate_size_t paramcount, gate_uint32_t flags)
{
    static gate_string_t current_dir = GATE_STRING_INIT_STATIC(".");
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_stream_t* ptr_stream = (gate_stream_t*)stream;
    gate_arraylist_t paths_to_check = NULL;
    gate_arraylist_t paths_to_links = NULL;
    gate_string_t const* ptr_path;
    gate_string_t const* ptr_link;
    gate_enumint_t attribs;
    gate_enumint_t accessbits;
    gate_result_t result;

    do
    {
        paths_to_check = gate_util_stringarray_create();
        if (NULL == paths_to_check)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        paths_to_links = gate_util_stringarray_create();
        if (NULL == paths_to_links)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        gate_arraylist_add(paths_to_check, &file_removelinks_params.path);

        while (gate_arraylist_length(paths_to_check) > 0)
        {
            ptr_path = (gate_string_t const*)gate_arraylist_get(paths_to_check, 0);
            if (ptr_path)
            {
                get_links_in_directory(ptr_path, paths_to_links, paths_to_check);
            }
            gate_arraylist_remove(paths_to_check, 0, 1);

            while (gate_arraylist_length(paths_to_links) > 0)
            {
                ptr_link = (gate_string_t const*)gate_arraylist_get(paths_to_links, 0);
                if (ptr_link)
                {
                    attribs = 0;
                    result = gate_file_get_attributes(ptr_link, &attribs, &accessbits);
                    if (GATE_SUCCEEDED(result))
                    {
                        if (GATE_FLAG_ENABLED(attribs, GATE_FILEENTRY_ATTRIB_DIRECTORY))
                        {
                            gate_stream_print_string(ptr_stream, ptr_link);
                            gate_stream_println_cstr(ptr_stream, NULL);
                            if (!file_removelinks_params.dry_run)
                            {
                                result = gate_file_dir_delete(ptr_link);
                                if (GATE_FAILED(result))
                                {
                                    gate_stream_println_cstr(ptr_stream, "Failed to remove link to directory");
                                }
                            }
                        }
                        else
                        {
                            gate_stream_print_string(ptr_stream, ptr_link);
                            gate_stream_println_cstr(ptr_stream, NULL);
                            if (!file_removelinks_params.dry_run)
                            {
                                result = gate_file_delete(ptr_link);
                                if (GATE_FAILED(result))
                                {
                                    gate_stream_println_cstr(ptr_stream, "Failed to remove link to file");
                                }
                            }
                        }
                    }
                }
                gate_arraylist_remove(paths_to_links, 0, 1);
            }

        }

        ret = GATE_RESULT_OK;
    } while (0);

    gate_arraylist_release(paths_to_links);
    gate_arraylist_release(paths_to_check);

    return ret;
}

gatecli_function_t file_functions[] =
{
    GATECLI_FUNCTION_PARAMS("copy", &unit_file_copy, unit_file_copy_params, "Copies a source file into a destination file"),
    GATECLI_FUNCTION_PARAMS("xcopy", &unit_file_xcopy, unit_file_xcopy_params, "Copies contents of a list or directory"),
    GATECLI_FUNCTION_PARAMS("move", &unit_file_move, unit_file_move_params, "Moves a source file to a destination path"),
    GATECLI_FUNCTION_PARAMS("delete", &unit_file_delete, unit_file_delete_params, "Deletes a file"),
    GATECLI_FUNCTION_PARAMS("link", &unit_file_link, unit_file_link_params, "Create a link to the source file in the destination path"),
    GATECLI_FUNCTION_PARAMS("readlink", &unit_file_readlink, unit_file_readlink_params, "Reads the target path of a link"),
    GATECLI_FUNCTION_PARAMS("get-owner", &unit_file_getowner, unit_file_getowner_params, "Returns the owner account of the given path"),
    GATECLI_FUNCTION_PARAMS("list", &unit_file_list, unit_file_list_params, "Lists the contents of a directory"),
    GATECLI_FUNCTION_PARAMS("qlist", &unit_file_qlist, unit_file_qlist_params, "Lists the paths of the contents of a directory"),
    GATECLI_FUNCTION("list-volumes", &unit_file_listvolumes, "Lists the paths of root volumes"),
    GATECLI_FUNCTION_PARAMS("setdate", &unit_file_setdate, unit_file_setdate_params, "Changes file dates"),
    GATECLI_FUNCTION_PARAMS("find", &unit_file_find, unit_file_find_params, "Searches for files with a specific name pattern"),
    GATECLI_FUNCTION_PARAMS("hashlist-create", &unit_file_hashlistcreate, unit_file_hashlistcreate_params, "Generates a hashlist about contents of a path"),
    GATECLI_FUNCTION_PARAMS("find-links", &unit_file_findlinks, unit_file_findlinks_params, "Finds all links in a directory"),
    GATECLI_FUNCTION_PARAMS("remove-links", &unit_file_removelinks, unit_file_removelinks_params, "Removes all links in a directory structure")
};

gatecli_unit_t global_unit_file =
{
    "file",
    "File and directory management functions",
    &file_functions[0],
    sizeof(file_functions) / sizeof(file_functions[0])
};

gatecli_unit_t* unit_file()
{
    return &global_unit_file;
}