packages/iSulad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
iSulad/src/liblcrc.c

1383 lines
29 KiB
C
Raw Normal View History

Package init
2019-09-30 10:53:41 -04:00
/******************************************************************************
* Copyright (c) Huawei Technologies Co., Ltd. 2018-2019. All rights reserved.
* iSulad licensed under the Mulan PSL v1.
* You can use this software according to the terms and conditions of the Mulan PSL v1.
* You may obtain a copy of Mulan PSL v1 at:
* http://license.coscl.org.cn/MulanPSL
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
* PURPOSE.
* See the Mulan PSL v1 for more details.
* Author: tanyifeng
* Create: 2018-11-08
* Description: provide container lcrc library functions
******************************************************************************/
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include "liblcrc.h"
#include "log.h"
#include "pack_config.h"
#include "utils.h"
/* lcrc filters free */
void lcrc_filters_free(struct lcrc_filters *filters)
{
size_t i;
if (filters == NULL) {
return;
}
for (i = 0; i < filters->len; i++) {
free(filters->keys[i]);
filters->keys[i] = NULL;
free(filters->values[i]);
filters->values[i] = NULL;
}
free(filters->keys);
filters->keys = NULL;
free(filters->values);
filters->values = NULL;
free(filters);
}
struct lcrc_filters *lcrc_filters_parse_args(const char **array, size_t len)
{
struct lcrc_filters *filters = NULL;
size_t i;
if (len == 0 || array == NULL) {
return NULL;
}
if (len > (SIZE_MAX / sizeof(char *))) {
ERROR("Too many filters");
return NULL;
}
filters = util_common_calloc_s(sizeof(*filters));
if (filters == NULL) {
ERROR("Out of memory");
return NULL;
}
filters->keys = util_common_calloc_s(sizeof(char *) * len);
if (filters->keys == NULL) {
ERROR("Out of memory");
goto cleanup;
}
filters->values = util_common_calloc_s(sizeof(char *) * len);
if (filters->values == NULL) {
free(filters->keys);
filters->keys = NULL;
ERROR("Out of memory");
goto cleanup;
}
for (i = 0; i < len; i++) {
char *valuepos = NULL;
char *copy = NULL;
char *lowerkey = NULL;
if (strlen(array[i]) == 0) {
continue;
}
copy = util_strdup_s(array[i]);
valuepos = strchr(copy, '=');
if (valuepos == NULL) {
COMMAND_ERROR("Bad format of filter '%s', (expected name=value)", copy);
free(copy);
goto cleanup;
}
*valuepos++ = '\0';
filters->values[filters->len] = util_strdup_s(util_trim_space(valuepos));
lowerkey = strings_to_lower(util_trim_space(copy));
free(copy);
if (lowerkey == NULL) {
free(filters->values[filters->len]);
filters->values[filters->len] = NULL;
ERROR("Out of memory");
goto cleanup;
}
filters->keys[filters->len] = lowerkey;
filters->len++;
}
return filters;
cleanup:
lcrc_filters_free(filters);
return NULL;
}
/* lcrc container info free */
void lcrc_container_info_free(struct lcrc_container_info *info)
{
if (info == NULL) {
return;
}
free(info->id);
info->id = NULL;
free(info);
}
/* lcrc version request free */
void lcrc_version_request_free(struct lcrc_version_request *request)
{
if (request == NULL) {
return;
}
free(request);
}
/* lcrc version response free */
void lcrc_version_response_free(struct lcrc_version_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response->version);
response->version = NULL;
free(response->git_commit);
response->git_commit = NULL;
free(response->build_time);
response->build_time = NULL;
free(response->root_path);
response->root_path = NULL;
free(response);
}
/* lcrc info request free */
void lcrc_info_request_free(struct lcrc_info_request *request)
{
if (request == NULL) {
return;
}
free(request);
}
/* lcrc info response free */
void lcrc_info_response_free(struct lcrc_info_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response->version);
response->version = NULL;
free(response->kversion);
response->kversion = NULL;
free(response->os_type);
response->os_type = NULL;
free(response->architecture);
response->architecture = NULL;
free(response->nodename);
response->nodename = NULL;
free(response->operating_system);
response->operating_system = NULL;
free(response->cgroup_driver);
response->cgroup_driver = NULL;
free(response->logging_driver);
response->logging_driver = NULL;
free(response->huge_page_size);
response->huge_page_size = NULL;
free(response->isulad_root_dir);
response->isulad_root_dir = NULL;
free(response->http_proxy);
response->http_proxy = NULL;
free(response->https_proxy);
response->https_proxy = NULL;
free(response->no_proxy);
response->no_proxy = NULL;
free(response);
}
void lcrc_ns_change_files_free(lcrc_host_config_t *hostconfig)
{
if (hostconfig == NULL) {
return;
}
util_free_array(hostconfig->ns_change_files);
hostconfig->ns_change_files = NULL;
hostconfig->ns_change_files_len = 0;
}
void lcrc_host_config_storage_opts_free(lcrc_host_config_t *hostconfig)
{
if (hostconfig == NULL) {
return;
}
free_json_map_string_string(hostconfig->storage_opts);
hostconfig->storage_opts = NULL;
}
void lcrc_host_config_sysctl_free(lcrc_host_config_t *hostconfig)
{
if (hostconfig == NULL) {
return;
}
free_json_map_string_string(hostconfig->sysctls);
hostconfig->sysctls = NULL;
}
/* lcrc host config free */
void lcrc_host_config_free(lcrc_host_config_t *hostconfig)
{
if (hostconfig == NULL) {
return;
}
util_free_array(hostconfig->cap_add);
hostconfig->cap_add = NULL;
hostconfig->cap_add_len = 0;
util_free_array(hostconfig->cap_drop);
hostconfig->cap_drop = NULL;
hostconfig->cap_drop_len = 0;
free_json_map_string_string(hostconfig->storage_opts);
hostconfig->storage_opts = NULL;
free_json_map_string_string(hostconfig->sysctls);
hostconfig->sysctls = NULL;
util_free_array(hostconfig->devices);
hostconfig->devices = NULL;
hostconfig->devices_len = 0;
util_free_array(hostconfig->hugetlbs);
hostconfig->hugetlbs = NULL;
hostconfig->hugetlbs_len = 0;
free(hostconfig->network_mode);
hostconfig->network_mode = NULL;
free(hostconfig->ipc_mode);
hostconfig->ipc_mode = NULL;
free(hostconfig->pid_mode);
hostconfig->pid_mode = NULL;
free(hostconfig->uts_mode);
hostconfig->uts_mode = NULL;
free(hostconfig->userns_mode);
hostconfig->userns_mode = NULL;
free(hostconfig->user_remap);
hostconfig->user_remap = NULL;
util_free_array(hostconfig->ulimits);
hostconfig->ulimits = NULL;
hostconfig->ulimits_len = 0;
free(hostconfig->restart_policy);
hostconfig->restart_policy = NULL;
free(hostconfig->host_channel);
hostconfig->host_channel = NULL;
free(hostconfig->hook_spec);
hostconfig->hook_spec = NULL;
free(hostconfig->env_target_file);
hostconfig->env_target_file = NULL;
free(hostconfig->cgroup_parent);
hostconfig->cgroup_parent = NULL;
util_free_array(hostconfig->binds);
hostconfig->binds = NULL;
hostconfig->binds_len = 0;
util_free_array(hostconfig->blkio_weight_device);
hostconfig->blkio_weight_device = NULL;
hostconfig->blkio_weight_device_len = 0;
container_cgroup_resources_free(hostconfig->cr);
hostconfig->cr = NULL;
free(hostconfig);
}
/* lcrc container config free */
void lcrc_container_config_free(lcrc_container_config_t *config)
{
if (config == NULL) {
return;
}
util_free_array(config->env);
config->env = NULL;
config->env_len = 0;
free(config->hostname);
config->hostname = NULL;
free(config->user);
config->user = NULL;
util_free_array(config->mounts);
config->mounts = NULL;
config->mounts_len = 0;
util_free_array(config->cmd);
config->cmd = NULL;
config->cmd_len = 0;
free(config->entrypoint);
config->entrypoint = NULL;
free(config->log_file);
config->log_file = NULL;
free(config->log_file_size);
config->log_file_size = NULL;
free_json_map_string_string(config->annotations);
config->annotations = NULL;
free(config->workdir);
config->workdir = NULL;
free(config);
}
/* lcrc create request free */
void lcrc_create_request_free(struct lcrc_create_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request->rootfs);
request->rootfs = NULL;
free(request->image);
request->image = NULL;
free(request->runtime);
request->runtime = NULL;
lcrc_host_config_free(request->hostconfig);
request->hostconfig = NULL;
lcrc_container_config_free(request->config);
request->config = NULL;
free(request);
}
/* lcrc create response free */
void lcrc_create_response_free(struct lcrc_create_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response->id);
response->id = NULL;
free(response);
}
/* lcrc start request free */
void lcrc_start_request_free(struct lcrc_start_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request->stdin);
request->stdin = NULL;
free(request->stdout);
request->stdout = NULL;
free(request->stderr);
request->stderr = NULL;
free(request);
}
/* lcrc start response free */
void lcrc_start_response_free(struct lcrc_start_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc_top_request_free */
void lcrc_top_request_free(struct lcrc_top_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
if (request->ps_argc && request->ps_args != NULL) {
int i;
for (i = 0; i < request->ps_argc; i++) {
free(request->ps_args[i]);
request->ps_args[i] = NULL;
}
free(request->ps_args);
request->ps_args = NULL;
request->ps_argc = 0;
}
free(request);
}
/* lcrc_top_response_free */
void lcrc_top_response_free(struct lcrc_top_response *response)
{
if (response == NULL) {
return;
}
free(response->titles);
response->titles = NULL;
if (response->processes_len && response->processes != NULL) {
size_t i;
for (i = 0; i < response->processes_len; i++) {
free(response->processes[i]);
response->processes[i] = NULL;
}
free(response->processes);
response->processes = NULL;
response->processes_len = 0;
}
free(response);
}
/* lcrc stop request free */
void lcrc_stop_request_free(struct lcrc_stop_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request);
}
/* lcrc stop response free */
void lcrc_stop_response_free(struct lcrc_stop_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc restart request free */
void lcrc_restart_request_free(struct lcrc_restart_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request);
}
/* lcrc restart response free */
void lcrc_restart_response_free(struct lcrc_restart_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc delete request free */
void lcrc_delete_request_free(struct lcrc_delete_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request);
}
/* lcrc delete response free */
void lcrc_delete_response_free(struct lcrc_delete_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response->name);
response->name = NULL;
free(response);
}
/* lcrc list request free */
void lcrc_list_request_free(struct lcrc_list_request *request)
{
if (request == NULL) {
return;
}
free(request);
}
/* lcrc list response free */
void lcrc_list_response_free(struct lcrc_list_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
if (response->container_num > 0 && response->container_summary != NULL) {
int i;
for (i = 0; i < (int)response->container_num; i++) {
if (response->container_summary[i]->id != NULL) {
free(response->container_summary[i]->id);
response->container_summary[i]->id = NULL;
}
if (response->container_summary[i]->name != NULL) {
free(response->container_summary[i]->name);
response->container_summary[i]->name = NULL;
}
if (response->container_summary[i]->runtime != NULL) {
free(response->container_summary[i]->runtime);
response->container_summary[i]->runtime = NULL;
}
if (response->container_summary[i]->image != NULL) {
free(response->container_summary[i]->image);
response->container_summary[i]->image = NULL;
}
if (response->container_summary[i]->command != NULL) {
free(response->container_summary[i]->command);
response->container_summary[i]->command = NULL;
}
if (response->container_summary[i]->startat != NULL) {
free(response->container_summary[i]->startat);
response->container_summary[i]->startat = NULL;
}
if (response->container_summary[i]->finishat != NULL) {
free(response->container_summary[i]->finishat);
response->container_summary[i]->finishat = NULL;
}
if (response->container_summary[i]->health_state != NULL) {
free(response->container_summary[i]->health_state);
response->container_summary[i]->health_state = NULL;
}
free(response->container_summary[i]);
response->container_summary[i] = NULL;
}
free(response->container_summary);
response->container_summary = NULL;
}
free(response);
}
/* lcrc exec request free */
void lcrc_exec_request_free(struct lcrc_exec_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request->stdout);
request->stdout = NULL;
free(request->stdin);
request->stdin = NULL;
free(request->stderr);
request->stderr = NULL;
if (request->argc && request->argv != NULL) {
int i;
for (i = 0; i < request->argc; i++) {
free(request->argv[i]);
request->argv[i] = NULL;
}
free(request->argv);
request->argv = NULL;
request->argc = 0;
}
if (request->env_len && request->env != NULL) {
size_t j;
for (j = 0; j < request->env_len; j++) {
free(request->env[j]);
request->env[j] = NULL;
}
free(request->env);
request->env = NULL;
request->env_len = 0;
}
free(request);
}
/* lcrc exec response free */
void lcrc_exec_response_free(struct lcrc_exec_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc attach request free */
void lcrc_attach_request_free(struct lcrc_attach_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request->stderr);
request->stderr = NULL;
free(request->stdout);
request->stdout = NULL;
free(request->stdin);
request->stdin = NULL;
free(request);
}
/* lcrc attach response free */
void lcrc_attach_response_free(struct lcrc_attach_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc pause request free */
void lcrc_pause_request_free(struct lcrc_pause_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request);
}
/* lcrc pause response free */
void lcrc_pause_response_free(struct lcrc_pause_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc resume request free */
void lcrc_resume_request_free(struct lcrc_resume_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request);
}
/* lcrc resume response free */
void lcrc_resume_response_free(struct lcrc_resume_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc container conf request free */
void lcrc_container_conf_request_free(struct lcrc_container_conf_request *req)
{
if (req == NULL) {
return;
}
free(req->name);
req->name = NULL;
free(req);
}
/* lcrc container conf response free */
void lcrc_container_conf_response_free(struct lcrc_container_conf_response *resp)
{
if (resp == NULL) {
return;
}
free(resp->errmsg);
resp->errmsg = NULL;
free(resp->container_logpath);
resp->container_logpath = NULL;
free(resp->container_logsize);
resp->container_logsize = NULL;
free(resp);
}
/* lcrc kill request free */
void lcrc_kill_request_free(struct lcrc_kill_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request);
}
/* lcrc kill response free */
void lcrc_kill_response_free(struct lcrc_kill_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc update config free */
void lcrc_update_config_free(lcrc_update_config_t *config)
{
if (config == NULL) {
return;
}
free(config->restart_policy);
config->restart_policy = NULL;
container_cgroup_resources_free(config->cr);
config->cr = NULL;
free(config);
}
/* lcrc update request free */
void lcrc_update_request_free(struct lcrc_update_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
lcrc_update_config_free(request->updateconfig);
request->updateconfig = NULL;
free(request);
}
/* lcrc update response free */
void lcrc_update_response_free(struct lcrc_update_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc stats request free */
void lcrc_stats_request_free(struct lcrc_stats_request *request)
{
if (request == NULL) {
return;
}
free(request->runtime);
request->runtime = NULL;
free(request);
}
/* lcrc stats response free */
void lcrc_stats_response_free(struct lcrc_stats_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
if (response->container_stats != NULL && response->container_num) {
int i;
for (i = 0; i < (int)response->container_num; i++) {
free(response->container_stats[i].id);
response->container_stats[i].id = NULL;
}
free(response->container_stats);
response->container_stats = NULL;
}
free(response);
}
/* lcrc events request free */
void lcrc_events_request_free(struct lcrc_events_request *request)
{
if (request == NULL) {
return;
}
free(request->id);
request->id = NULL;
free(request);
}
/* lcrc events response free */
void lcrc_events_response_free(struct lcrc_events_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
void lcrc_copy_from_container_request_free(struct lcrc_copy_from_container_request *request)
{
if (request == NULL) {
return;
}
free(request->id);
request->id = NULL;
free(request->runtime);
request->runtime = NULL;
free(request->srcpath);
request->srcpath = NULL;
free(request);
}
void lcrc_copy_from_container_response_free(struct lcrc_copy_from_container_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free_container_path_stat(response->stat);
response->stat = NULL;
free(response);
}
void lcrc_copy_to_container_request_free(struct lcrc_copy_to_container_request *request)
{
if (request == NULL) {
return;
}
free(request->id);
request->id = NULL;
free(request->runtime);
request->runtime = NULL;
free(request->srcpath);
request->srcpath = NULL;
free(request->srcrebase);
request->srcrebase = NULL;
free(request->dstpath);
request->dstpath = NULL;
free(request);
}
void lcrc_copy_to_container_response_free(struct lcrc_copy_to_container_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc inspect request free */
void lcrc_inspect_request_free(struct lcrc_inspect_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request);
}
/* lcrc inspect response free */
void lcrc_inspect_response_free(struct lcrc_inspect_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response->json);
response->json = NULL;
free(response);
}
/* lcrc wait request free */
void lcrc_wait_request_free(struct lcrc_wait_request *request)
{
if (request == NULL) {
return;
}
free(request->id);
request->id = NULL;
free(request);
}
/* lcrc wait response free */
void lcrc_wait_response_free(struct lcrc_wait_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc health check request free */
void lcrc_health_check_request_free(struct lcrc_health_check_request *request)
{
if (request == NULL) {
return;
}
free(request->service);
request->service = NULL;
free(request);
}
/* lcrc health check response free */
void lcrc_health_check_response_free(struct lcrc_health_check_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc create image request free */
void lcrc_create_image_request_free(struct lcrc_create_image_request *request)
{
if (request == NULL) {
return;
}
free(request->image_info.imageref);
request->image_info.imageref = NULL;
free(request->image_info.type);
request->image_info.type = NULL;
free(request->image_info.digest);
request->image_info.digest = NULL;
free(request);
return;
}
/* lcrc create image response free */
void lcrc_create_image_response_free(struct lcrc_create_image_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response->image_info.imageref);
response->image_info.imageref = NULL;
free(response->image_info.type);
response->image_info.type = NULL;
free(response->image_info.digest);
response->image_info.digest = NULL;
free(response);
return;
}
/* lcrc images list free */
void lcrc_images_list_free(size_t images_num, struct lcrc_image_info *images_list)
{
int i = 0;
struct lcrc_image_info *in = NULL;
if (images_num == 0 || images_list == NULL) {
return;
}
for (i = 0, in = images_list; i < (int)images_num; i++, in++) {
free(in->imageref);
free(in->type);
free(in->digest);
}
free(images_list);
return;
}
/* lcrc list images request free */
void lcrc_list_images_request_free(struct lcrc_list_images_request *request)
{
if (request == NULL) {
return;
}
free(request);
return;
}
/* lcrc list images response free */
void lcrc_list_images_response_free(struct lcrc_list_images_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
lcrc_images_list_free(response->images_num, response->images_list);
response->images_num = 0;
response->images_list = NULL;
free(response);
}
/* lcrc rmi request free */
void lcrc_rmi_request_free(struct lcrc_rmi_request *request)
{
if (request == NULL) {
return;
}
free(request->image_name);
request->image_name = NULL;
free(request);
return;
}
/* lcrc rmi response free */
void lcrc_rmi_response_free(struct lcrc_rmi_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
return;
}
/* lcrc pull response free */
void lcrc_pull_request_free(struct lcrc_pull_request *request)
{
if (request == NULL) {
return;
}
free(request->image_name);
request->image_name = NULL;
free(request);
return;
}
/* lcrc pull response free */
void lcrc_pull_response_free(struct lcrc_pull_response *response)
{
if (response == NULL) {
return;
}
free(response->image_ref);
response->image_ref = NULL;
free(response->errmsg);
response->errmsg = NULL;
free(response);
return;
}
/* lcrc load request free */
void lcrc_load_request_free(struct lcrc_load_request *request)
{
if (request == NULL) {
return;
}
free(request->file);
request->file = NULL;
free(request->type);
request->type = NULL;
free(request->tag);
request->tag = NULL;
free(request);
return;
}
/* lcrc load response free */
void lcrc_load_response_free(struct lcrc_load_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
return;
}
/* lcrc login response free */
void lcrc_login_response_free(struct lcrc_login_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
return;
}
/* lcrc logout response free */
void lcrc_logout_response_free(struct lcrc_logout_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
return;
}
/* lcrc export request free */
void lcrc_export_request_free(struct lcrc_export_request *request)
{
if (request == NULL) {
return;
}
free(request->name);
request->name = NULL;
free(request->file);
request->file = NULL;
free(request);
}
/* lcrc export response free */
void lcrc_export_response_free(struct lcrc_export_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc rename request free */
void lcrc_rename_request_free(struct lcrc_rename_request *request)
{
if (request == NULL) {
return;
}
free(request->old_name);
request->old_name = NULL;
free(request->new_name);
request->new_name = NULL;
free(request);
}
/* lcrc rename response free */
void lcrc_rename_response_free(struct lcrc_rename_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
/* lcrc logs request free */
void lcrc_logs_request_free(struct lcrc_logs_request *request)
{
if (request == NULL) {
return;
}
free(request->id);
request->id = NULL;
free(request->runtime);
request->runtime = NULL;
free(request->since);
request->since = NULL;
free(request->until);
request->until = NULL;
free(request);
}
/* lcrc logs response free */
void lcrc_logs_response_free(struct lcrc_logs_response *response)
{
if (response == NULL) {
return;
}
free(response->errmsg);
response->errmsg = NULL;
free(response);
}
Reference in New Issue Copy Permalink