--- /dev/null
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include <limits.h>
+#include <string.h>
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
+
+static grpc_arg copy_arg(const grpc_arg* src) {
+ grpc_arg dst;
+ dst.type = src->type;
+ dst.key = gpr_strdup(src->key);
+ switch (dst.type) {
+ case GRPC_ARG_STRING:
+ dst.value.string = gpr_strdup(src->value.string);
+ break;
+ case GRPC_ARG_INTEGER:
+ dst.value.integer = src->value.integer;
+ break;
+ case GRPC_ARG_POINTER:
+ dst.value.pointer = src->value.pointer;
+ dst.value.pointer.p =
+ src->value.pointer.vtable->copy(src->value.pointer.p);
+ break;
+ }
+ return dst;
+}
+
+grpc_channel_args* grpc_channel_args_copy_and_add(const grpc_channel_args* src,
+ const grpc_arg* to_add,
+ size_t num_to_add) {
+ return grpc_channel_args_copy_and_add_and_remove(src, nullptr, 0, to_add,
+ num_to_add);
+}
+
+grpc_channel_args* grpc_channel_args_copy_and_remove(
+ const grpc_channel_args* src, const char** to_remove,
+ size_t num_to_remove) {
+ return grpc_channel_args_copy_and_add_and_remove(src, to_remove,
+ num_to_remove, nullptr, 0);
+}
+
+static bool should_remove_arg(const grpc_arg* arg, const char** to_remove,
+ size_t num_to_remove) {
+ for (size_t i = 0; i < num_to_remove; ++i) {
+ if (strcmp(arg->key, to_remove[i]) == 0) return true;
+ }
+ return false;
+}
+
+grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
+ const grpc_channel_args* src, const char** to_remove, size_t num_to_remove,
+ const grpc_arg* to_add, size_t num_to_add) {
+ // Figure out how many args we'll be copying.
+ size_t num_args_to_copy = 0;
+ if (src != nullptr) {
+ for (size_t i = 0; i < src->num_args; ++i) {
+ if (!should_remove_arg(&src->args[i], to_remove, num_to_remove)) {
+ ++num_args_to_copy;
+ }
+ }
+ }
+ // Create result.
+ grpc_channel_args* dst =
+ static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
+ dst->num_args = num_args_to_copy + num_to_add;
+ if (dst->num_args == 0) {
+ dst->args = nullptr;
+ return dst;
+ }
+ dst->args =
+ static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * dst->num_args));
+ // Copy args from src that are not being removed.
+ size_t dst_idx = 0;
+ if (src != nullptr) {
+ for (size_t i = 0; i < src->num_args; ++i) {
+ if (!should_remove_arg(&src->args[i], to_remove, num_to_remove)) {
+ dst->args[dst_idx++] = copy_arg(&src->args[i]);
+ }
+ }
+ }
+ // Add args from to_add.
+ for (size_t i = 0; i < num_to_add; ++i) {
+ dst->args[dst_idx++] = copy_arg(&to_add[i]);
+ }
+ GPR_ASSERT(dst_idx == dst->num_args);
+ return dst;
+}
+
+grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src) {
+ return grpc_channel_args_copy_and_add(src, nullptr, 0);
+}
+
+grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
+ const grpc_channel_args* b) {
+ if (a == nullptr) return grpc_channel_args_copy(b);
+ if (b == nullptr) return grpc_channel_args_copy(a);
+ const size_t max_out = (a->num_args + b->num_args);
+ grpc_arg* uniques =
+ static_cast<grpc_arg*>(gpr_malloc(sizeof(*uniques) * max_out));
+ for (size_t i = 0; i < a->num_args; ++i) uniques[i] = a->args[i];
+
+ size_t uniques_idx = a->num_args;
+ for (size_t i = 0; i < b->num_args; ++i) {
+ const char* b_key = b->args[i].key;
+ if (grpc_channel_args_find(a, b_key) == nullptr) { // not found
+ uniques[uniques_idx++] = b->args[i];
+ }
+ }
+ grpc_channel_args* result =
+ grpc_channel_args_copy_and_add(nullptr, uniques, uniques_idx);
+ gpr_free(uniques);
+ return result;
+}
+
+static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
+ int c = GPR_ICMP(a->type, b->type);
+ if (c != 0) return c;
+ c = strcmp(a->key, b->key);
+ if (c != 0) return c;
+ switch (a->type) {
+ case GRPC_ARG_STRING:
+ return strcmp(a->value.string, b->value.string);
+ case GRPC_ARG_INTEGER:
+ return GPR_ICMP(a->value.integer, b->value.integer);
+ case GRPC_ARG_POINTER:
+ c = GPR_ICMP(a->value.pointer.p, b->value.pointer.p);
+ if (c != 0) {
+ c = GPR_ICMP(a->value.pointer.vtable, b->value.pointer.vtable);
+ if (c == 0) {
+ c = a->value.pointer.vtable->cmp(a->value.pointer.p,
+ b->value.pointer.p);
+ }
+ }
+ return c;
+ }
+ GPR_UNREACHABLE_CODE(return 0);
+}
+
+/* stabilizing comparison function: since channel_args ordering matters for
+ * keys with the same name, we need to preserve that ordering */
+static int cmp_key_stable(const void* ap, const void* bp) {
+ const grpc_arg* const* a = static_cast<const grpc_arg* const*>(ap);
+ const grpc_arg* const* b = static_cast<const grpc_arg* const*>(bp);
+ int c = strcmp((*a)->key, (*b)->key);
+ if (c == 0) c = GPR_ICMP(*a, *b);
+ return c;
+}
+
+grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
+ grpc_arg** args =
+ static_cast<grpc_arg**>(gpr_malloc(sizeof(grpc_arg*) * a->num_args));
+ for (size_t i = 0; i < a->num_args; i++) {
+ args[i] = &a->args[i];
+ }
+ if (a->num_args > 1)
+ qsort(args, a->num_args, sizeof(grpc_arg*), cmp_key_stable);
+
+ grpc_channel_args* b =
+ static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
+ b->num_args = a->num_args;
+ b->args = static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * b->num_args));
+ for (size_t i = 0; i < a->num_args; i++) {
+ b->args[i] = copy_arg(args[i]);
+ }
+
+ gpr_free(args);
+ return b;
+}
+
+void grpc_channel_args_destroy(grpc_channel_args* a) {
+ size_t i;
+ if (!a) return;
+ for (i = 0; i < a->num_args; i++) {
+ switch (a->args[i].type) {
+ case GRPC_ARG_STRING:
+ gpr_free(a->args[i].value.string);
+ break;
+ case GRPC_ARG_INTEGER:
+ break;
+ case GRPC_ARG_POINTER:
+ a->args[i].value.pointer.vtable->destroy(a->args[i].value.pointer.p);
+ break;
+ }
+ gpr_free(a->args[i].key);
+ }
+ gpr_free(a->args);
+ gpr_free(a);
+}
+
+int grpc_channel_args_compare(const grpc_channel_args* a,
+ const grpc_channel_args* b) {
+ if (a == nullptr && b == nullptr) return 0;
+ if (a == nullptr || b == nullptr) return a == nullptr ? -1 : 1;
+ int c = GPR_ICMP(a->num_args, b->num_args);
+ if (c != 0) return c;
+ for (size_t i = 0; i < a->num_args; i++) {
+ c = cmp_arg(&a->args[i], &b->args[i]);
+ if (c != 0) return c;
+ }
+ return 0;
+}
+
+const grpc_arg* grpc_channel_args_find(const grpc_channel_args* args,
+ const char* name) {
+ if (args != nullptr) {
+ for (size_t i = 0; i < args->num_args; ++i) {
+ if (strcmp(args->args[i].key, name) == 0) {
+ return &args->args[i];
+ }
+ }
+ }
+ return nullptr;
+}
+
+int grpc_channel_arg_get_integer(const grpc_arg* arg,
+ const grpc_integer_options options) {
+ if (arg == nullptr) return options.default_value;
+ if (arg->type != GRPC_ARG_INTEGER) {
+ gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
+ return options.default_value;
+ }
+ if (arg->value.integer < options.min_value) {
+ gpr_log(GPR_ERROR, "%s ignored: it must be >= %d", arg->key,
+ options.min_value);
+ return options.default_value;
+ }
+ if (arg->value.integer > options.max_value) {
+ gpr_log(GPR_ERROR, "%s ignored: it must be <= %d", arg->key,
+ options.max_value);
+ return options.default_value;
+ }
+ return arg->value.integer;
+}
+
+int grpc_channel_args_find_integer(const grpc_channel_args* args,
+ const char* name,
+ const grpc_integer_options options) {
+ const grpc_arg* arg = grpc_channel_args_find(args, name);
+ return grpc_channel_arg_get_integer(arg, options);
+}
+
+char* grpc_channel_arg_get_string(const grpc_arg* arg) {
+ if (arg == nullptr) return nullptr;
+ if (arg->type != GRPC_ARG_STRING) {
+ gpr_log(GPR_ERROR, "%s ignored: it must be an string", arg->key);
+ return nullptr;
+ }
+ return arg->value.string;
+}
+
+char* grpc_channel_args_find_string(const grpc_channel_args* args,
+ const char* name) {
+ const grpc_arg* arg = grpc_channel_args_find(args, name);
+ return grpc_channel_arg_get_string(arg);
+}
+
+bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
+ if (arg == nullptr) return default_value;
+ if (arg->type != GRPC_ARG_INTEGER) {
+ gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
+ return default_value;
+ }
+ switch (arg->value.integer) {
+ case 0:
+ return false;
+ case 1:
+ return true;
+ default:
+ gpr_log(GPR_ERROR, "%s treated as bool but set to %d (assuming true)",
+ arg->key, arg->value.integer);
+ return true;
+ }
+}
+
+bool grpc_channel_args_find_bool(const grpc_channel_args* args,
+ const char* name, bool default_value) {
+ const grpc_arg* arg = grpc_channel_args_find(args, name);
+ return grpc_channel_arg_get_bool(arg, default_value);
+}
+
+bool grpc_channel_args_want_minimal_stack(const grpc_channel_args* args) {
+ return grpc_channel_arg_get_bool(
+ grpc_channel_args_find(args, GRPC_ARG_MINIMAL_STACK), false);
+}
+
+grpc_arg grpc_channel_arg_string_create(char* name, char* value) {
+ grpc_arg arg;
+ arg.type = GRPC_ARG_STRING;
+ arg.key = name;
+ arg.value.string = value;
+ return arg;
+}
+
+grpc_arg grpc_channel_arg_integer_create(char* name, int value) {
+ grpc_arg arg;
+ arg.type = GRPC_ARG_INTEGER;
+ arg.key = name;
+ arg.value.integer = value;
+ return arg;
+}
+
+grpc_arg grpc_channel_arg_pointer_create(
+ char* name, void* value, const grpc_arg_pointer_vtable* vtable) {
+ grpc_arg arg;
+ arg.type = GRPC_ARG_POINTER;
+ arg.key = name;
+ arg.value.pointer.p = value;
+ arg.value.pointer.vtable = vtable;
+ return arg;
+}
+
+char* grpc_channel_args_string(const grpc_channel_args* args) {
+ if (args == nullptr) return nullptr;
+ gpr_strvec v;
+ gpr_strvec_init(&v);
+ for (size_t i = 0; i < args->num_args; ++i) {
+ const grpc_arg& arg = args->args[i];
+ char* s;
+ switch (arg.type) {
+ case GRPC_ARG_INTEGER:
+ gpr_asprintf(&s, "%s=%d", arg.key, arg.value.integer);
+ break;
+ case GRPC_ARG_STRING:
+ gpr_asprintf(&s, "%s=%s", arg.key, arg.value.string);
+ break;
+ case GRPC_ARG_POINTER:
+ gpr_asprintf(&s, "%s=%p", arg.key, arg.value.pointer.p);
+ break;
+ default:
+ gpr_asprintf(&s, "arg with unknown type");
+ }
+ gpr_strvec_add(&v, s);
+ }
+ char* result =
+ gpr_strjoin_sep(const_cast<const char**>(v.strs), v.count, ", ", nullptr);
+ gpr_strvec_destroy(&v);
+ return result;
+}
git://repos.xcallymotion.com / motion2.git / blobdiff