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

1022 lines
30 KiB
C
Raw Normal View History

Package init
2019-09-30 10:35:21 -04:00
/******************************************************************************
* Copyright (c) Huawei Technologies Co., Ltd. 2019. All rights reserved.
* clibcni 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: 2019-04-25
* Description: provide cni api functions
********************************************************************************/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include "api.h"
#include "log.h"
#include "invoke_errno.h"
#include "current.h"
#include "conf.h"
#include "args.h"
#include "tools.h"
#include "exec.h"
#include "utils.h"
#include "types.h"
static int add_network_list(const struct network_config_list *list, const struct runtime_conf *rc,
const char * const *paths, size_t paths_len, struct result **pret, char **err);
static int del_network_list(const struct network_config_list *list, const struct runtime_conf *rc,
const char * const *paths, size_t paths_len, char **err);
static int add_network(const struct network_config *net, const struct runtime_conf *rc, const char * const *paths,
size_t paths_len, struct result **add_result, char **err);
static int del_network(const struct network_config *net, const struct runtime_conf *rc, const char * const *paths,
size_t paths_len, char **err);
static int args(const char *action, const struct runtime_conf *rc, const char * const *paths, size_t paths_len,
struct cni_args **cargs, char **err);
static int copy_cni_port_mapping(port_mapping *dst, const struct cni_port_mapping *src)
{
bool invalid_arg = (dst == NULL || src == NULL);
if (invalid_arg) {
return -1;
}
if (src->protocol != NULL) {
dst->protocol = util_strdup_s(src->protocol);
}
if (src->host_ip != NULL) {
dst->host_ip = util_strdup_s(src->host_ip);
}
dst->container_port = src->container_port;
dst->host_port = src->host_port;
return 0;
}
static int inject_port_mappings(const struct runtime_conf *rt, net_conf_runtime_config *rt_config, char **err)
{
size_t j = 0;
if (rt_config->port_mappings != NULL) {
for (j = 0; j < rt_config->port_mappings_len; j++) {
free_port_mapping(rt_config->port_mappings[j]);
rt_config->port_mappings[j] = NULL;
}
free(rt_config->port_mappings);
rt_config->port_mappings = NULL;
}
if (rt->p_mapping_len > (SIZE_MAX / sizeof(port_mapping *))) {
*err = util_strdup_s("Too many mapping");
ERROR("Too many mapping");
return -1;
}
rt_config->port_mappings = util_common_calloc_s(sizeof(port_mapping *) * (rt->p_mapping_len));
if (rt_config->port_mappings == NULL) {
*err = util_strdup_s("Out of memory");
ERROR("Out of memory");
return -1;
}
for (j = 0; j < rt->p_mapping_len; j++) {
rt_config->port_mappings[j] = util_common_calloc_s(sizeof(port_mapping));
if (rt_config->port_mappings[j] == NULL) {
*err = util_strdup_s("Out of memory");
ERROR("Out of memory");
return -1;
}
(rt_config->port_mappings_len)++;
if (copy_cni_port_mapping(rt_config->port_mappings[j], rt->p_mapping[j]) != 0) {
*err = util_strdup_s("Out of memory");
ERROR("Out of memory");
return -1;
}
}
return 0;
}
static int inject_runtime_config_items(const struct network_config *orig, const struct runtime_conf *rt,
net_conf_runtime_config **rt_config, bool *inserted, char **err)
{
char *work = NULL;
bool value = false;
int ret = -1;
size_t i = 0;
*rt_config = util_common_calloc_s(sizeof(net_conf_runtime_config));
if (*rt_config == NULL) {
*err = util_strdup_s("Out of memory");
ERROR("Out of memory");
goto free_out;
}
for (i = 0; i < orig->network->capabilities->len; i++) {
work = orig->network->capabilities->keys[i];
value = orig->network->capabilities->values[i];
if (!value || work == NULL) {
continue;
}
if (strcmp(work, "portMappings") == 0 && rt->p_mapping_len > 0) {
if (inject_port_mappings(rt, *rt_config, err) != 0) {
ERROR("Inject port mappings failed");
goto free_out;
}
*inserted = true;
}
/* new capabilities add here */
}
ret = 0;
free_out:
return ret;
}
static int do_generate_net_conf_json(const struct network_config *orig, char **result, char **err)
{
struct parser_context ctx = { OPT_GEN_SIMPLIFY, 0 };
parser_error jerr = NULL;
int ret = 0;
/* generate new json str for injected config */
*result = net_conf_generate_json(orig->network, &ctx, &jerr);
if (*result == NULL) {
if (asprintf(err, "generate json failed: %s", jerr) < 0) {
*err = util_strdup_s("Out of memory");
ERROR("Out of memory");
}
ERROR("Generate json: %s", jerr);
ret = -1;
goto out;
}
out:
free(jerr);
return ret;
}
static inline bool check_inject_runtime_config_args(const struct network_config *orig, const struct runtime_conf *rt,
char * const *result, char * const *err)
{
return (orig == NULL || rt == NULL || result == NULL || err == NULL);
}
static int inject_runtime_config(const struct network_config *orig, const struct runtime_conf *rt, char **result,
char **err)
{
bool insert_rt_config = false;
int ret = -1;
net_conf_runtime_config *rt_config = NULL;
net_conf_runtime_config *save_conf = NULL;
if (check_inject_runtime_config_args(orig, rt, result, err)) {
ERROR("Invalid arguments");
return -1;
}
if (orig->network == NULL || orig->network->capabilities == NULL) {
return 0;
}
save_conf = orig->network->runtime_config;
ret = inject_runtime_config_items(orig, rt, &rt_config, &insert_rt_config, err);
if (ret != 0) {
ERROR("inject runtime config failed: %s", *err != NULL ? *err : "");
goto free_out;
}
if (!insert_rt_config) {
goto generate_result;
}
orig->network->runtime_config = rt_config;
generate_result:
ret = do_generate_net_conf_json(orig, result, err);
free_out:
orig->network->runtime_config = save_conf;
free_net_conf_runtime_config(rt_config);
if (ret != 0) {
free(*result);
*result = NULL;
}
return ret;
}
static int do_inject_prev_result(const struct result *prev_result, net_conf *work, char **err)
{
if (prev_result == NULL) {
return 0;
}
free_result_curr(work->prev_result);
work->prev_result = result_curr_to_json_result(prev_result, err);
if (work->prev_result == NULL) {
return -1;
}
return 0;
}
static inline bool check_build_one_config(const struct network_config_list *list, const struct network_config *orig,
const struct runtime_conf *rt, char * const *result, char * const *err)
{
return (list == NULL || orig == NULL || rt == NULL || result == NULL || err == NULL);
}
static int build_one_config(const struct network_config_list *list, struct network_config *orig,
const struct result *prev_result, const struct runtime_conf *rt, char **result, char **err)
{
int ret = -1;
net_conf *work = NULL;
if (check_build_one_config(list, orig, rt, result, err)) {
ERROR("Invalid arguments");
return ret;
}
work = orig->network;
free(work->name);
work->name = util_strdup_s(list->list->name);
free(work->cni_version);
work->cni_version = util_strdup_s(list->list->cni_version);
if (do_inject_prev_result(prev_result, work, err) != 0) {
ERROR("Inject pre result failed: %s", *err != NULL ? *err : "");
goto free_out;
}
if (inject_runtime_config(orig, rt, result, err) != 0) {
ERROR("Inject runtime config failed: %s", *err != NULL ? *err : "");
goto free_out;
}
ret = 0;
free_out:
if (ret != 0 && *err == NULL) {
*err = util_strdup_s("Out of memory");
}
return ret;
}
static int do_check_generate_net_conf_json(char **full_conf_bytes, struct network_config *pnet, char **err)
{
struct parser_context ctx = { OPT_GEN_SIMPLIFY, 0 };
parser_error serr = NULL;
int ret = 0;
if (*full_conf_bytes != NULL) {
pnet->bytes = *full_conf_bytes;
*full_conf_bytes = NULL;
} else {
pnet->bytes = net_conf_generate_json(pnet->network, &ctx, &serr);
if (pnet->bytes == NULL) {
if (asprintf(err, "Generate json failed: %s", serr) < 0) {
*err = util_strdup_s("Out of memory");
}
ERROR("Generate json: %s", serr);
ret = -1;
goto out;
}
}
out:
free(serr);
return ret;
}
static int run_cni_plugin(const struct network_config_list *list, size_t i, const char *operator,
const struct runtime_conf *rc, const char * const *paths, size_t paths_len,
struct result **pret, char **err)
{
int ret = -1;
struct network_config net = { 0 };
char *plugin_path = NULL;
struct cni_args *cargs = NULL;
char *full_conf_bytes = NULL;
struct result *tmp_result = NULL;
int save_errno = 0;
net.network = list->list->plugins[i];
if (net.network == NULL) {
*err = util_strdup_s("Empty network");
ERROR("Empty network");
goto free_out;
}
ret = find_in_path(net.network->type, paths, paths_len, &plugin_path, &save_errno);
if (ret != 0) {
if (asprintf(err, "find plugin: \"%s\" failed: %s", net.network->type, get_invoke_err_msg(save_errno)) < 0) {
*err = util_strdup_s("Out of memory");
}
ERROR("find plugin: \"%s\" failed: %s", net.network->type, get_invoke_err_msg(save_errno));
goto free_out;
}
tmp_result = pret != NULL ? *pret : NULL;
ret = build_one_config(list, &net, tmp_result, rc, &full_conf_bytes, err);
if (ret != 0) {
ERROR("build config failed: %s", *err != NULL ? *err : "");
goto free_out;
}
ret = do_check_generate_net_conf_json(&full_conf_bytes, &net, err);
if (ret != 0) {
ERROR("check gengerate net config failed: %s", *err != NULL ? *err : "");
goto free_out;
}
ret = args(operator, rc, paths, paths_len, &cargs, err);
if (ret != 0) {
ERROR("get plugin arguments failed: %s", *err != NULL ? *err : "");
goto free_out;
}
if (pret == NULL) {
ret = exec_plugin_without_result(plugin_path, net.bytes, cargs, err);
} else {
free_result(*pret);
*pret = NULL;
ret = exec_plugin_with_result(plugin_path, net.bytes, cargs, pret, err);
}
free_out:
free_cni_args(cargs);
free(plugin_path);
free(net.bytes);
return ret;
}
static inline bool check_add_network_list_args(const struct network_config_list *list, const struct runtime_conf *rc,
struct result * const *pret, char * const *err)
{
return (list == NULL || list->list == NULL || rc == NULL || pret == NULL || err == NULL);
}
static int add_network_list(const struct network_config_list *list, const struct runtime_conf *rc,
const char * const *paths, size_t paths_len, struct result **pret, char **err)
{
int ret = -1;
size_t i = 0;
struct result *prev_result = NULL;
if (check_add_network_list_args(list, rc, pret, err)) {
ERROR("Empty arguments");
return -1;
}
for (i = 0; i < list->list->plugins_len; i++) {
ret = run_cni_plugin(list, i, "ADD", rc, paths, paths_len, &prev_result, err);
if (ret != 0) {
ERROR("Run ADD cni failed: %s", *err != NULL ? *err : "");
goto free_out;
}
}
*pret = prev_result;
ret = 0;
free_out:
if (ret != 0) {
free_result(prev_result);
}
return ret;
}
static inline bool check_del_network_list_args(const struct network_config_list *list, const struct runtime_conf *rc,
char * const *err)
{
return (list == NULL || list->list == NULL || rc == NULL || err == NULL);
}
static int del_network_list(const struct network_config_list *list, const struct runtime_conf *rc,
const char * const *paths, size_t paths_len, char **err)
{
size_t i = 0;
int ret = 0;
if (check_del_network_list_args(list, rc, err)) {
ERROR("Empty arguments");
return -1;
}
for (i = list->list->plugins_len; i > 0; i--) {
ret = run_cni_plugin(list, (i - 1), "DEL", rc, paths, paths_len, NULL, err);
if (ret != 0) {
ERROR("Run DEL cni failed: %s", *err != NULL ? *err : "");
goto free_out;
}
}
free_out:
return ret;
}
static inline bool check_add_network_args(const struct network_config *net, const struct runtime_conf *rc,
char * const *err)
{
return (net == NULL || rc == NULL || err == NULL);
}
static int add_network(const struct network_config *net, const struct runtime_conf *rc, const char * const *paths,
size_t paths_len, struct result **add_result, char **err)
{
int ret = 0;
char *plugin_path = NULL;
char *net_bytes = NULL;
struct cni_args *cargs = NULL;
int save_errno = 0;
if (check_add_network_args(net, rc, err)) {
ERROR("Empty arguments");
return -1;
}
ret = find_in_path(net->network->type, paths, paths_len, &plugin_path, &save_errno);
if (ret != 0) {
if (asprintf(err, "find plugin: \"%s\" failed: %s", net->network->type, get_invoke_err_msg(save_errno)) < 0) {
*err = util_strdup_s("Out of memory");
}
ERROR("find plugin: \"%s\" failed: %s", net->network->type, get_invoke_err_msg(save_errno));
goto free_out;
}
ret = inject_runtime_config(net, rc, &net_bytes, err);
if (ret != 0) {
ERROR("Inject runtime config: %s", *err != NULL ? *err : "");
goto free_out;
}
ret = args("ADD", rc, paths, paths_len, &cargs, err);
if (ret != 0) {
ERROR("Get ADD cni arguments: %s", *err != NULL ? *err : "");
goto free_out;
}
ret = exec_plugin_with_result(plugin_path, net_bytes, cargs, add_result, err);
free_out:
free(plugin_path);
free(net_bytes);
free_cni_args(cargs);
return ret;
}
static inline bool check_del_network_args(const struct network_config *net, const struct runtime_conf *rc,
char * const *err)
{
return (net == NULL || net->network == NULL || rc == NULL || err == NULL);
}
static int del_network(const struct network_config *net, const struct runtime_conf *rc, const char * const *paths,
size_t paths_len, char **err)
{
int ret = 0;
char *plugin_path = NULL;
char *net_bytes = NULL;
struct cni_args *cargs = NULL;
int save_errno = 0;
if (check_del_network_args(net, rc, err)) {
ERROR("Empty arguments");
return -1;
}
ret = find_in_path(net->network->type, paths, paths_len, &plugin_path, &save_errno);
if (ret != 0) {
if (asprintf(err, "find plugin: \"%s\" failed: %s", net->network->type, get_invoke_err_msg(save_errno)) < 0) {
*err = util_strdup_s("Out of memory");
}
ERROR("find plugin: \"%s\" failed: %s", net->network->type, get_invoke_err_msg(save_errno));
goto free_out;
}
ret = inject_runtime_config(net, rc, &net_bytes, err);
if (ret != 0) {
ERROR("Inject runtime config: %s", *err != NULL ? *err : "");
goto free_out;
}
ret = args("DEL", rc, paths, paths_len, &cargs, err);
if (ret != 0) {
ERROR("Get DEL cni arguments: %s", *err != NULL ? *err : "");
goto free_out;
}
ret = exec_plugin_without_result(plugin_path, net_bytes, cargs, err);
free_out:
free(plugin_path);
free(net_bytes);
free_cni_args(cargs);
return ret;
}
static int do_copy_plugin_args(const struct runtime_conf *rc, struct cni_args **cargs)
{
size_t i = 0;
if (rc->args_len == 0) {
return 0;
}
if (rc->args_len > (INT_MAX / sizeof(char *)) / 2) {
ERROR("Large arguments");
return -1;
}
(*cargs)->plugin_args = util_common_calloc_s((rc->args_len) * sizeof(char *) * 2);
if ((*cargs)->plugin_args == NULL) {
ERROR("Out of memory");
return -1;
}
for (i = 0; i < rc->args_len; i++) {
(*cargs)->plugin_args[i][0] = util_strdup_s(rc->args[i][0]);
(*cargs)->plugin_args[i][1] = util_strdup_s(rc->args[i][1]);
(*cargs)->plugin_args_len = (i + 1);
}
return 0;
}
static int copy_args(const struct runtime_conf *rc, struct cni_args **cargs)
{
if (rc->container_id != NULL) {
(*cargs)->container_id = util_strdup_s(rc->container_id);
}
if (rc->netns != NULL) {
(*cargs)->netns = util_strdup_s(rc->netns);
}
if (rc->ifname != NULL) {
(*cargs)->ifname = util_strdup_s(rc->ifname);
}
return do_copy_plugin_args(rc, cargs);
}
static int do_copy_args_paths(const char * const *paths, size_t paths_len, struct cni_args **cargs)
{
if (paths == NULL) {
return 0;
}
if (paths_len == 0) {
(*cargs)->path = util_strdup_s("");
} else {
(*cargs)->path = cni_util_string_join(":", paths, paths_len);
if ((*cargs)->path == NULL) {
ERROR("Out of memory");
return -1;
}
}
return 0;
}
static inline bool check_args_args(const struct runtime_conf *rc, struct cni_args * const *cargs, char * const *err)
{
return (rc == NULL || cargs == NULL || err == NULL);
}
static int args(const char *action, const struct runtime_conf *rc, const char * const *paths, size_t paths_len,
struct cni_args **cargs, char **err)
{
int ret = -1;
if (check_args_args(rc, cargs, err)) {
ERROR("Empty arguments");
return ret;
}
*cargs = util_common_calloc_s(sizeof(struct cni_args));
if (*cargs == NULL) {
*err = util_strdup_s("Out of memory");
ERROR("Out of memory");
goto free_out;
}
if (action != NULL) {
(*cargs)->command = util_strdup_s(action);
}
if (do_copy_args_paths(paths, paths_len, cargs) != 0) {
goto free_out;
}
ret = copy_args(rc, cargs);
free_out:
if (ret != 0) {
free_cni_args(*cargs);
*cargs = NULL;
if (*err == NULL) {
*err = util_strdup_s("Out of memory");
}
}
return ret;
}
void free_cni_port_mapping(struct cni_port_mapping *val)
{
if (val != NULL) {
free(val->protocol);
free(val->host_ip);
free(val);
}
}
void free_cni_network_conf(struct cni_network_conf *val)
{
if (val != NULL) {
free(val->name);
free(val->type);
free(val->bytes);
free(val);
}
}
void free_cni_network_list_conf(struct cni_network_list_conf *val)
{
if (val != NULL) {
free(val->bytes);
free(val->name);
free(val->first_plugin_name);
free(val->first_plugin_type);
free(val);
}
}
void free_runtime_conf(struct runtime_conf *rc)
{
size_t i = 0;
if (rc == NULL) {
return;
}
free(rc->container_id);
rc->container_id = NULL;
free(rc->netns);
rc->netns = NULL;
free(rc->ifname);
rc->ifname = NULL;
for (i = 0; i < rc->args_len; i++) {
free(rc->args[i][0]);
free(rc->args[i][1]);
}
free(rc->args);
rc->args = NULL;
for (i = 0; i < rc->p_mapping_len; i++) {
free_cni_port_mapping(rc->p_mapping[i]);
}
free(rc->p_mapping);
rc->p_mapping = NULL;
free(rc);
}
int cni_add_network_list(const char *net_list_conf_str, const struct runtime_conf *rc, char **paths,
struct result **pret, char **err)
{
struct network_config_list *list = NULL;
int ret = 0;
size_t len = 0;
if (err == NULL) {
ERROR("Empty arguments");
return -1;
}
if (net_list_conf_str == NULL) {
*err = util_strdup_s("Empty net list conf argument");
ERROR("Empty net list conf argument");
return -1;
}
ret = conflist_from_bytes(net_list_conf_str, &list, err);
if (ret != 0) {
ERROR("Parse conf list failed: %s", *err != NULL ? *err : "");
return ret;
}
len = util_array_len((const char * const *)paths);
ret = add_network_list(list, rc, (const char * const *)paths, len, pret, err);
DEBUG("Add network list return with: %d", ret);
free_network_config_list(list);
return ret;
}
int cni_add_network(const char *net_conf_str, const struct runtime_conf *rc, char **paths, struct result **add_result,
char **err)
{
struct network_config *net = NULL;
int ret = 0;
size_t len = 0;
if (err == NULL) {
ERROR("Empty err");
return -1;
}
if (net_conf_str == NULL) {
*err = util_strdup_s("Empty net conf argument");
ERROR("Empty net conf argument");
return -1;
}
ret = conf_from_bytes(net_conf_str, &net, err);
if (ret != 0) {
ERROR("Parse conf failed: %s", *err != NULL ? *err : "");
return ret;
}
len = util_array_len((const char * const *)paths);
ret = add_network(net, rc, (const char * const *)paths, len, add_result, err);
free_network_config(net);
return ret;
}
int cni_del_network_list(const char *net_list_conf_str, const struct runtime_conf *rc, char **paths, char **err)
{
struct network_config_list *list = NULL;
int ret = 0;
size_t len = 0;
if (err == NULL) {
ERROR("Empty err");
return -1;
}
if (net_list_conf_str == NULL) {
*err = util_strdup_s("Empty net list conf argument");
ERROR("Empty net list conf argument");
return -1;
}
ret = conflist_from_bytes(net_list_conf_str, &list, err);
if (ret != 0) {
ERROR("Parse conf list failed: %s", *err != NULL ? *err : "");
return ret;
}
len = util_array_len((const char * const *)paths);
ret = del_network_list(list, rc, (const char * const *)paths, len, err);
DEBUG("Delete network list return with: %d", ret);
free_network_config_list(list);
return ret;
}
int cni_del_network(const char *net_conf_str, const struct runtime_conf *rc, char **paths, char **err)
{
struct network_config *net = NULL;
int ret = 0;
size_t len = 0;
if (err == NULL) {
ERROR("Empty err");
return -1;
}
if (net_conf_str == NULL) {
*err = util_strdup_s("Empty net conf argument");
ERROR("Empty net conf argument");
return -1;
}
ret = conf_from_bytes(net_conf_str, &net, err);
if (ret != 0) {
ERROR("Parse conf failed: %s", *err != NULL ? *err : "");
return ret;
}
len = util_array_len((const char * const *)paths);
ret = del_network(net, rc, (const char * const *)paths, len, err);
free_network_config(net);
return ret;
}
int cni_get_version_info(const char *plugin_type, char **paths, struct plugin_info **pinfo, char **err)
{
int ret = 0;
char *plugin_path = NULL;
size_t len;
int save_errno = 0;
if (err == NULL) {
ERROR("Empty err");
return -1;
}
len = util_array_len((const char * const *)paths);
ret = find_in_path(plugin_type, (const char * const *)paths, len, &plugin_path, &save_errno);
if (ret != 0) {
if (asprintf(err, "find plugin: \"%s\" failed: %s", plugin_type, get_invoke_err_msg(save_errno)) < 0) {
*err = util_strdup_s("Out of memory");
}
ERROR("find plugin: \"%s\" failed: %s", plugin_type, get_invoke_err_msg(save_errno));
return ret;
}
ret = raw_get_version_info(plugin_path, pinfo, err);
free(plugin_path);
return ret;
}
int cni_conf_files(const char *dir, const char **extensions, size_t ext_len, char ***result, char **err)
{
if (err == NULL) {
ERROR("Empty err");
return -1;
}
return conf_files(dir, extensions, ext_len, result, err);
}
int cni_conf_from_file(const char *filename, struct cni_network_conf **config, char **err)
{
int ret = 0;
struct network_config *netconf = NULL;
if (err == NULL) {
ERROR("Empty err");
return -1;
}
ret = conf_from_file(filename, &netconf, err);
if (ret != 0) {
ERROR("Parse conf file: %s failed: %s", filename, *err != NULL ? *err : "");
return ret;
}
*config = util_common_calloc_s(sizeof(struct cni_network_conf));
if (*config == NULL) {
*err = util_strdup_s("Out of memory");
ret = -1;
ERROR("Out of memory");
goto free_out;
}
if (netconf != NULL && netconf->network != NULL) {
(*config)->type = netconf->network->type ? util_strdup_s(netconf->network->type) : NULL;
(*config)->name = netconf->network->name ? util_strdup_s(netconf->network->name) : NULL;
}
if (netconf != NULL) {
(*config)->bytes = netconf->bytes;
netconf->bytes = NULL;
}
ret = 0;
free_out:
free_network_config(netconf);
return ret;
}
static void json_obj_to_cni_list_conf(struct network_config_list *src, struct cni_network_list_conf *list)
{
if (src == NULL) {
return;
}
list->bytes = src->bytes;
src->bytes = NULL;
if (src->list != NULL) {
list->name = src->list->name ? util_strdup_s(src->list->name) : NULL;
list->plugin_len = src->list->plugins_len;
if (src->list->plugins_len > 0 && src->list->plugins != NULL && src->list->plugins[0] != NULL) {
list->first_plugin_name = src->list->plugins[0]->name != NULL ?
util_strdup_s(src->list->plugins[0]->name) : NULL;
list->first_plugin_type = src->list->plugins[0]->type != NULL ?
util_strdup_s(src->list->plugins[0]->type) : NULL;
}
}
}
int cni_conflist_from_bytes(const char *bytes, struct cni_network_list_conf **list, char **err)
{
struct network_config_list *tmp_net_conf_list = NULL;
int ret = 0;
if (err == NULL) {
ERROR("Empty err");
return -1;
}
ret = conflist_from_bytes(bytes, &tmp_net_conf_list, err);
if (ret != 0) {
return ret;
}
*list = util_common_calloc_s(sizeof(struct cni_network_list_conf));
if (*list == NULL) {
*err = util_strdup_s("Out of memory");
ret = -1;
ERROR("Out of memory");
goto free_out;
}
json_obj_to_cni_list_conf(tmp_net_conf_list, *list);
ret = 0;
free_out:
free_network_config_list(tmp_net_conf_list);
return ret;
}
int cni_conflist_from_file(const char *filename, struct cni_network_list_conf **list, char **err)
{
struct network_config_list *tmp_net_conf_list = NULL;
int ret = 0;
if (err == NULL) {
ERROR("Empty err");
return -1;
}
ret = conflist_from_file(filename, &tmp_net_conf_list, err);
if (ret != 0) {
return ret;
}
*list = util_common_calloc_s(sizeof(struct cni_network_list_conf));
if (*list == NULL) {
*err = util_strdup_s("Out of memory");
ret = -1;
ERROR("Out of memory");
goto free_out;
}
json_obj_to_cni_list_conf(tmp_net_conf_list, *list);
ret = 0;
free_out:
free_network_config_list(tmp_net_conf_list);
return ret;
}
static inline bool check_cni_conflist_from_conf_args(const struct cni_network_conf *cni_conf,
struct cni_network_list_conf * const *cni_conf_list)
{
return (cni_conf == NULL || cni_conf_list == NULL);
}
int cni_conflist_from_conf(const struct cni_network_conf *cni_conf, struct cni_network_list_conf **cni_conf_list,
char **err)
{
struct network_config *net = NULL;
struct network_config_list *net_list = NULL;
int ret = 0;
bool invalid_arg = false;
if (err == NULL) {
ERROR("Empty err");
return -1;
}
invalid_arg = check_cni_conflist_from_conf_args(cni_conf, cni_conf_list);
if (invalid_arg) {
*err = util_strdup_s("Empty cni conf or conflist argument");
ERROR("Empty cni conf or conflist argument");
return -1;
}
ret = conf_from_bytes(cni_conf->bytes, &net, err);
if (ret != 0) {
goto free_out;
}
ret = conflist_from_conf(net, &net_list, err);
if (ret != 0) {
goto free_out;
}
*cni_conf_list = util_common_calloc_s(sizeof(struct cni_network_list_conf));
if (*cni_conf_list == NULL) {
*err = util_strdup_s("Out of memory");
ERROR("Out of memory");
ret = -1;
goto free_out;
}
json_obj_to_cni_list_conf(net_list, *cni_conf_list);
ret = 0;
free_out:
if (net != NULL) {
free_network_config(net);
}
free_network_config_list(net_list);
return ret;
}
int cni_log_init(const char *driver, const char *file, const char *priority)
{
struct clibcni_log_config conf = { 0 };
conf.name = "clibcni";
conf.driver = driver;
conf.file = file;
conf.priority = priority;
return clibcni_log_enable(&conf);
}
void cni_set_log_prefix(const char *prefix)
{
clibcni_set_log_prefix(prefix);
}
void cni_free_log_prefix()
{
clibcni_free_log_prefix();
}
Reference in New Issue Copy Permalink