grpc 1.26.0 → 1.27.0.pre1

data/src/core/lib/json/json_common.h

@@ -1,34 +0,0 @@
-/*
- *
- * 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.
- *
- */
-
-#ifndef GRPC_CORE_LIB_JSON_JSON_COMMON_H
-#define GRPC_CORE_LIB_JSON_JSON_COMMON_H
-
-/* The various json types. */
-typedef enum {
-  GRPC_JSON_OBJECT,
-  GRPC_JSON_ARRAY,
-  GRPC_JSON_STRING,
-  GRPC_JSON_NUMBER,
-  GRPC_JSON_TRUE,
-  GRPC_JSON_FALSE,
-  GRPC_JSON_NULL,
-  GRPC_JSON_TOP_LEVEL
-} grpc_json_type;
-
-#endif /* GRPC_CORE_LIB_JSON_JSON_COMMON_H */

data/src/core/lib/json/json_reader.h

@@ -1,146 +0,0 @@
-/*
- *
- * 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.
- *
- */
-
-#ifndef GRPC_CORE_LIB_JSON_JSON_READER_H
-#define GRPC_CORE_LIB_JSON_JSON_READER_H
-
-#include <grpc/support/port_platform.h>
-
-#include "src/core/lib/json/json_common.h"
-
-typedef enum {
-  GRPC_JSON_STATE_OBJECT_KEY_BEGIN,
-  GRPC_JSON_STATE_OBJECT_KEY_STRING,
-  GRPC_JSON_STATE_OBJECT_KEY_END,
-  GRPC_JSON_STATE_VALUE_BEGIN,
-  GRPC_JSON_STATE_VALUE_STRING,
-  GRPC_JSON_STATE_STRING_ESCAPE,
-  GRPC_JSON_STATE_STRING_ESCAPE_U1,
-  GRPC_JSON_STATE_STRING_ESCAPE_U2,
-  GRPC_JSON_STATE_STRING_ESCAPE_U3,
-  GRPC_JSON_STATE_STRING_ESCAPE_U4,
-  GRPC_JSON_STATE_VALUE_NUMBER,
-  GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL,
-  GRPC_JSON_STATE_VALUE_NUMBER_ZERO,
-  GRPC_JSON_STATE_VALUE_NUMBER_DOT,
-  GRPC_JSON_STATE_VALUE_NUMBER_E,
-  GRPC_JSON_STATE_VALUE_NUMBER_EPM,
-  GRPC_JSON_STATE_VALUE_TRUE_R,
-  GRPC_JSON_STATE_VALUE_TRUE_U,
-  GRPC_JSON_STATE_VALUE_TRUE_E,
-  GRPC_JSON_STATE_VALUE_FALSE_A,
-  GRPC_JSON_STATE_VALUE_FALSE_L,
-  GRPC_JSON_STATE_VALUE_FALSE_S,
-  GRPC_JSON_STATE_VALUE_FALSE_E,
-  GRPC_JSON_STATE_VALUE_NULL_U,
-  GRPC_JSON_STATE_VALUE_NULL_L1,
-  GRPC_JSON_STATE_VALUE_NULL_L2,
-  GRPC_JSON_STATE_VALUE_END,
-  GRPC_JSON_STATE_END
-} grpc_json_reader_state;
-
-enum {
-  /* The first non-unicode value is 0x110000. But let's pick
-   * a value high enough to start our error codes from. These
-   * values are safe to return from the read_char function.
-   */
-  GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0,
-  GRPC_JSON_READ_CHAR_EAGAIN,
-  GRPC_JSON_READ_CHAR_ERROR
-};
-
-struct grpc_json_reader;
-
-typedef struct grpc_json_reader_vtable {
-  /* Clears your internal string scratchpad. */
-  void (*string_clear)(void* userdata);
-  /* Adds a char to the string scratchpad. */
-  void (*string_add_char)(void* userdata, uint32_t c);
-  /* Adds a utf32 char to the string scratchpad. */
-  void (*string_add_utf32)(void* userdata, uint32_t c);
-  /* Reads a character from your input. May be utf-8, 16 or 32. */
-  uint32_t (*read_char)(void* userdata);
-  /* Starts a container of type GRPC_JSON_ARRAY or GRPC_JSON_OBJECT. */
-  void (*container_begins)(void* userdata, grpc_json_type type);
-  /* Ends the current container. Must return the type of its parent. */
-  grpc_json_type (*container_ends)(void* userdata);
-  /* Your internal string scratchpad is an object's key. */
-  void (*set_key)(void* userdata);
-  /* Your internal string scratchpad is a string value. */
-  void (*set_string)(void* userdata);
-  /* Your internal string scratchpad is a numerical value. Return 1 if valid. */
-  int (*set_number)(void* userdata);
-  /* Sets the values true, false or null. */
-  void (*set_true)(void* userdata);
-  void (*set_false)(void* userdata);
-  void (*set_null)(void* userdata);
-} grpc_json_reader_vtable;
-
-typedef struct grpc_json_reader {
-  /* That structure is fully private, and initialized by grpc_json_reader_init.
-   * The definition is public so you can put it on your stack.
-   */
-
-  void* userdata;
-  grpc_json_reader_vtable* vtable;
-  int depth;
-  int in_object;
-  int in_array;
-  int escaped_string_was_key;
-  int container_just_begun;
-  uint16_t unicode_char, unicode_high_surrogate;
-  grpc_json_reader_state state;
-} grpc_json_reader;
-
-/* The return type of the parser. */
-typedef enum {
-  GRPC_JSON_DONE,          /* The parser finished successfully. */
-  GRPC_JSON_EAGAIN,        /* The parser yields to get more data. */
-  GRPC_JSON_READ_ERROR,    /* The parser passes through a read error. */
-  GRPC_JSON_PARSE_ERROR,   /* The parser found an error in the json stream. */
-  GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */
-} grpc_json_reader_status;
-
-/* Call this function to start parsing the input. It will return the following:
- *    . GRPC_JSON_DONE if the input got eof, and the parsing finished
- *      successfully.
- *    . GRPC_JSON_EAGAIN if the read_char function returned again. Call the
- *      parser again as needed. It is okay to call the parser in polling mode,
- *      although a bit dull.
- *    . GRPC_JSON_READ_ERROR if the read_char function returned an error. The
- *      state isn't broken however, and the function can be called again if the
- *      error has been corrected. But please use the EAGAIN feature instead for
- *      consistency.
- *    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid.
- *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
- *      internal state.
- */
-grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader);
-
-/* Call this function to initialize the reader structure. */
-void grpc_json_reader_init(grpc_json_reader* reader,
-                           grpc_json_reader_vtable* vtable, void* userdata);
-
-/* You may call this from the read_char callback if you don't know where is the
- * end of your input stream, and you'd like the json reader to hint you that it
- * has completed reading its input, so you can return an EOF to it. Note that
- * there might still be trailing whitespaces after that point.
- */
-int grpc_json_reader_is_complete(grpc_json_reader* reader);
-
-#endif /* GRPC_CORE_LIB_JSON_JSON_READER_H */

data/src/core/lib/json/json_string.cc

@@ -1,367 +0,0 @@
-/*
- *
- * 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 <stdlib.h>
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_reader.h"
-#include "src/core/lib/json/json_writer.h"
-
-/* The json reader will construct a bunch of grpc_json objects and
- * link them all up together in a tree-like structure that will represent
- * the json data in memory.
- *
- * It also uses its own input as a scratchpad to store all of the decoded,
- * unescaped strings. So we need to keep track of all these pointers in
- * that opaque structure the reader will carry for us.
- *
- * Note that this works because the act of parsing json always reduces its
- * input size, and never expands it.
- */
-typedef struct {
-  grpc_json* top;
-  grpc_json* current_container;
-  grpc_json* current_value;
-  uint8_t* input;
-  uint8_t* key;
-  uint8_t* string;
-  uint8_t* string_ptr;
-  size_t remaining_input;
-} json_reader_userdata;
-
-/* This json writer will put everything in a big string.
- * The point is that we allocate that string in chunks of 256 bytes.
- */
-typedef struct {
-  char* output;
-  size_t free_space;
-  size_t string_len;
-  size_t allocated;
-} json_writer_userdata;
-
-/* This function checks if there's enough space left in the output buffer,
- * and will enlarge it if necessary. We're only allocating chunks of 256
- * bytes at a time (or multiples thereof).
- */
-static void json_writer_output_check(void* userdata, size_t needed) {
-  json_writer_userdata* state = static_cast<json_writer_userdata*>(userdata);
-  if (state->free_space >= needed) return;
-  needed -= state->free_space;
-  /* Round up by 256 bytes. */
-  needed = (needed + 0xff) & ~0xffU;
-  state->output =
-      static_cast<char*>(gpr_realloc(state->output, state->allocated + needed));
-  state->free_space += needed;
-  state->allocated += needed;
-}
-
-/* These are needed by the writer's implementation. */
-static void json_writer_output_char(void* userdata, char c) {
-  json_writer_userdata* state = static_cast<json_writer_userdata*>(userdata);
-  json_writer_output_check(userdata, 1);
-  state->output[state->string_len++] = c;
-  state->free_space--;
-}
-
-static void json_writer_output_string_with_len(void* userdata, const char* str,
-                                               size_t len) {
-  json_writer_userdata* state = static_cast<json_writer_userdata*>(userdata);
-  json_writer_output_check(userdata, len);
-  memcpy(state->output + state->string_len, str, len);
-  state->string_len += len;
-  state->free_space -= len;
-}
-
-static void json_writer_output_string(void* userdata, const char* str) {
-  size_t len = strlen(str);
-  json_writer_output_string_with_len(userdata, str, len);
-}
-
-/* The reader asks us to clear our scratchpad. In our case, we'll simply mark
- * the end of the current string, and advance our output pointer.
- */
-static void json_reader_string_clear(void* userdata) {
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-  if (state->string) {
-    GPR_ASSERT(state->string_ptr < state->input);
-    *state->string_ptr++ = 0;
-  }
-  state->string = state->string_ptr;
-}
-
-static void json_reader_string_add_char(void* userdata, uint32_t c) {
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-  GPR_ASSERT(state->string_ptr < state->input);
-  GPR_ASSERT(c <= 0xff);
-  *state->string_ptr++ = static_cast<uint8_t>(c);
-}
-
-/* We are converting a UTF-32 character into UTF-8 here,
- * as described by RFC3629.
- */
-static void json_reader_string_add_utf32(void* userdata, uint32_t c) {
-  if (c <= 0x7f) {
-    json_reader_string_add_char(userdata, c);
-  } else if (c <= 0x7ff) {
-    uint32_t b1 = 0xc0 | ((c >> 6) & 0x1f);
-    uint32_t b2 = 0x80 | (c & 0x3f);
-    json_reader_string_add_char(userdata, b1);
-    json_reader_string_add_char(userdata, b2);
-  } else if (c <= 0xffff) {
-    uint32_t b1 = 0xe0 | ((c >> 12) & 0x0f);
-    uint32_t b2 = 0x80 | ((c >> 6) & 0x3f);
-    uint32_t b3 = 0x80 | (c & 0x3f);
-    json_reader_string_add_char(userdata, b1);
-    json_reader_string_add_char(userdata, b2);
-    json_reader_string_add_char(userdata, b3);
-  } else if (c <= 0x1fffff) {
-    uint32_t b1 = 0xf0 | ((c >> 18) & 0x07);
-    uint32_t b2 = 0x80 | ((c >> 12) & 0x3f);
-    uint32_t b3 = 0x80 | ((c >> 6) & 0x3f);
-    uint32_t b4 = 0x80 | (c & 0x3f);
-    json_reader_string_add_char(userdata, b1);
-    json_reader_string_add_char(userdata, b2);
-    json_reader_string_add_char(userdata, b3);
-    json_reader_string_add_char(userdata, b4);
-  }
-}
-
-/* We consider that the input may be a zero-terminated string. So we
- * can end up hitting eof before the end of the alleged string length.
- */
-static uint32_t json_reader_read_char(void* userdata) {
-  uint32_t r;
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-
-  if (state->remaining_input == 0) return GRPC_JSON_READ_CHAR_EOF;
-
-  r = *state->input++;
-  state->remaining_input--;
-
-  if (r == 0) {
-    state->remaining_input = 0;
-    return GRPC_JSON_READ_CHAR_EOF;
-  }
-
-  return r;
-}
-
-/* Helper function to create a new grpc_json object and link it into
- * our tree-in-progress inside our opaque structure.
- */
-static grpc_json* json_create_and_link(void* userdata, grpc_json_type type) {
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-  grpc_json* json = grpc_json_create(type);
-
-  json->parent = state->current_container;
-  json->prev = state->current_value;
-  state->current_value = json;
-
-  if (json->prev) {
-    json->prev->next = json;
-  }
-  if (json->parent) {
-    if (!json->parent->child) {
-      json->parent->child = json;
-    }
-    if (json->parent->type == GRPC_JSON_OBJECT) {
-      json->key = reinterpret_cast<char*>(state->key);
-    }
-  }
-  if (!state->top) {
-    state->top = json;
-  }
-
-  return json;
-}
-
-static void json_reader_container_begins(void* userdata, grpc_json_type type) {
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-  grpc_json* container;
-
-  GPR_ASSERT(type == GRPC_JSON_ARRAY || type == GRPC_JSON_OBJECT);
-
-  container = json_create_and_link(userdata, type);
-  state->current_container = container;
-  state->current_value = nullptr;
-}
-
-/* It's important to remember that the reader is mostly stateless, so it
- * isn't trying to remember what the container was prior the one that just
- * ends. Since we're keeping track of these for our own purpose, we are
- * able to return that information back, which is useful for it to validate
- * the input json stream.
- *
- * Also note that if we're at the top of the tree, and the last container
- * ends, we have to return GRPC_JSON_TOP_LEVEL.
- */
-static grpc_json_type json_reader_container_ends(void* userdata) {
-  grpc_json_type container_type = GRPC_JSON_TOP_LEVEL;
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-
-  GPR_ASSERT(state->current_container);
-
-  state->current_value = state->current_container;
-  state->current_container = state->current_container->parent;
-
-  if (state->current_container) {
-    container_type = state->current_container->type;
-  }
-
-  return container_type;
-}
-
-/* The next 3 functions basically are the reader asking us to use our string
- * scratchpad for one of these 3 purposes.
- *
- * Note that in the set_number case, we're not going to try interpreting it.
- * We'll keep it as a string, and leave it to the caller to evaluate it.
- */
-static void json_reader_set_key(void* userdata) {
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-  state->key = state->string;
-}
-
-static void json_reader_set_string(void* userdata) {
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-  grpc_json* json = json_create_and_link(userdata, GRPC_JSON_STRING);
-  json->value = reinterpret_cast<char*>(state->string);
-}
-
-static int json_reader_set_number(void* userdata) {
-  json_reader_userdata* state = static_cast<json_reader_userdata*>(userdata);
-  grpc_json* json = json_create_and_link(userdata, GRPC_JSON_NUMBER);
-  json->value = reinterpret_cast<char*>(state->string);
-  return 1;
-}
-
-/* The object types true, false and null are self-sufficient, and don't need
- * any more information beside their type.
- */
-static void json_reader_set_true(void* userdata) {
-  json_create_and_link(userdata, GRPC_JSON_TRUE);
-}
-
-static void json_reader_set_false(void* userdata) {
-  json_create_and_link(userdata, GRPC_JSON_FALSE);
-}
-
-static void json_reader_set_null(void* userdata) {
-  json_create_and_link(userdata, GRPC_JSON_NULL);
-}
-
-static grpc_json_reader_vtable reader_vtable = {
-    json_reader_string_clear,     json_reader_string_add_char,
-    json_reader_string_add_utf32, json_reader_read_char,
-    json_reader_container_begins, json_reader_container_ends,
-    json_reader_set_key,          json_reader_set_string,
-    json_reader_set_number,       json_reader_set_true,
-    json_reader_set_false,        json_reader_set_null};
-
-/* And finally, let's define our public API. */
-grpc_json* grpc_json_parse_string_with_len(char* input, size_t size) {
-  grpc_json_reader reader;
-  json_reader_userdata state;
-  grpc_json* json = nullptr;
-  grpc_json_reader_status status;
-
-  if (!input) return nullptr;
-
-  state.top = state.current_container = state.current_value = nullptr;
-  state.string = state.key = nullptr;
-  state.string_ptr = state.input = reinterpret_cast<uint8_t*>(input);
-  state.remaining_input = size;
-  grpc_json_reader_init(&reader, &reader_vtable, &state);
-
-  status = grpc_json_reader_run(&reader);
-  json = state.top;
-
-  if ((status != GRPC_JSON_DONE) && json) {
-    grpc_json_destroy(json);
-    json = nullptr;
-  }
-
-  return json;
-}
-
-#define UNBOUND_JSON_STRING_LENGTH 0x7fffffff
-
-grpc_json* grpc_json_parse_string(char* input) {
-  return grpc_json_parse_string_with_len(input, UNBOUND_JSON_STRING_LENGTH);
-}
-
-static void json_dump_recursive(grpc_json_writer* writer, const grpc_json* json,
-                                int in_object) {
-  while (json) {
-    if (in_object) grpc_json_writer_object_key(writer, json->key);
-
-    switch (json->type) {
-      case GRPC_JSON_OBJECT:
-      case GRPC_JSON_ARRAY:
-        grpc_json_writer_container_begins(writer, json->type);
-        if (json->child)
-          json_dump_recursive(writer, json->child,
-                              json->type == GRPC_JSON_OBJECT);
-        grpc_json_writer_container_ends(writer, json->type);
-        break;
-      case GRPC_JSON_STRING:
-        grpc_json_writer_value_string(writer, json->value);
-        break;
-      case GRPC_JSON_NUMBER:
-        grpc_json_writer_value_raw(writer, json->value);
-        break;
-      case GRPC_JSON_TRUE:
-        grpc_json_writer_value_raw_with_len(writer, "true", 4);
-        break;
-      case GRPC_JSON_FALSE:
-        grpc_json_writer_value_raw_with_len(writer, "false", 5);
-        break;
-      case GRPC_JSON_NULL:
-        grpc_json_writer_value_raw_with_len(writer, "null", 4);
-        break;
-      default:
-        GPR_UNREACHABLE_CODE(abort());
-    }
-    json = json->next;
-  }
-}
-
-static grpc_json_writer_vtable writer_vtable = {
-    json_writer_output_char, json_writer_output_string,
-    json_writer_output_string_with_len};
-
-char* grpc_json_dump_to_string(const grpc_json* json, int indent) {
-  grpc_json_writer writer;
-  json_writer_userdata state;
-
-  state.output = nullptr;
-  state.free_space = state.string_len = state.allocated = 0;
-  grpc_json_writer_init(&writer, indent, &writer_vtable, &state);
-
-  json_dump_recursive(&writer, json, 0);
-
-  json_writer_output_char(&state, 0);
-
-  return state.output;
-}