grpc 1.51.0-x86_64-linux → 1.52.0-x86_64-linux

data/src/core/ext/transport/chttp2/server/chttp2_server.h

@@ -1,47 +0,0 @@
-/*
- *
- * Copyright 2016 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_EXT_TRANSPORT_CHTTP2_SERVER_CHTTP2_SERVER_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_SERVER_CHTTP2_SERVER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <functional>
-
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/surface/server.h"
-
-namespace grpc_core {
-
-// A function to modify channel args for a listening addr:port. Note that this
-// is used to create a security connector for listeners when the servers are
-// configured with a config fetcher. Not invoked if there is no config fetcher
-// added to the server. On failure, the error parameter will be set.
-using Chttp2ServerArgsModifier =
-    std::function<ChannelArgs(const ChannelArgs&, grpc_error_handle*)>;
-
-/// Adds a port to \a server.  Sets \a port_num to the port number.
-/// Takes ownership of \a args.
-grpc_error_handle Chttp2ServerAddPort(
-    Server* server, const char* addr, const ChannelArgs& args,
-    Chttp2ServerArgsModifier connection_args_modifier, int* port_num);
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_SERVER_CHTTP2_SERVER_H */

data/src/core/ext/transport/chttp2/transport/bin_decoder.cc

@@ -1,252 +0,0 @@
-/*
- *
- * Copyright 2016 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 "src/core/ext/transport/chttp2/transport/bin_decoder.h"
-
-#include "absl/base/attributes.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-#include "src/core/lib/slice/slice.h"
-
-static uint8_t decode_table[] = {
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 62,   0x40, 0x40, 0x40, 63,
-    52,   53,   54,   55,   56,   57,   58,   59,   60,   61,   0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0,    1,    2,    3,    4,    5,    6,
-    7,    8,    9,    10,   11,   12,   13,   14,   15,   16,   17,   18,
-    19,   20,   21,   22,   23,   24,   25,   0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,
-    37,   38,   39,   40,   41,   42,   43,   44,   45,   46,   47,   48,
-    49,   50,   51,   0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
-    0x40, 0x40, 0x40, 0x40};
-
-static const uint8_t tail_xtra[4] = {0, 0, 1, 2};
-
-static bool input_is_valid(const uint8_t* input_ptr, size_t length) {
-  size_t i;
-
-  for (i = 0; i < length; ++i) {
-    if (GPR_UNLIKELY((decode_table[input_ptr[i]] & 0xC0) != 0)) {
-      gpr_log(GPR_ERROR,
-              "Base64 decoding failed, invalid character '%c' in base64 "
-              "input.\n",
-              static_cast<char>(*input_ptr));
-      return false;
-    }
-  }
-  return true;
-}
-
-#define COMPOSE_OUTPUT_BYTE_0(input_ptr)          \
-  (uint8_t)((decode_table[(input_ptr)[0]] << 2) | \
-            (decode_table[(input_ptr)[1]] >> 4))
-
-#define COMPOSE_OUTPUT_BYTE_1(input_ptr)          \
-  (uint8_t)((decode_table[(input_ptr)[1]] << 4) | \
-            (decode_table[(input_ptr)[2]] >> 2))
-
-#define COMPOSE_OUTPUT_BYTE_2(input_ptr) \
-  (uint8_t)((decode_table[(input_ptr)[2]] << 6) | decode_table[(input_ptr)[3]])
-
-// By RFC 4648, if the length of the encoded string without padding is 4n+r,
-// the length of decoded string is: 1) 3n if r = 0, 2) 3n + 1 if r = 2, 3, or
-// 3) invalid if r = 1.
-size_t grpc_chttp2_base64_infer_length_after_decode(const grpc_slice& slice) {
-  size_t len = GRPC_SLICE_LENGTH(slice);
-  const uint8_t* bytes = GRPC_SLICE_START_PTR(slice);
-  while (len > 0 && bytes[len - 1] == '=') {
-    len--;
-  }
-  if (GPR_UNLIKELY(GRPC_SLICE_LENGTH(slice) - len > 2)) {
-    gpr_log(GPR_ERROR,
-            "Base64 decoding failed. Input has more than 2 paddings.");
-    return 0;
-  }
-  size_t tuples = len / 4;
-  size_t tail_case = len % 4;
-  if (GPR_UNLIKELY(tail_case == 1)) {
-    gpr_log(GPR_ERROR,
-            "Base64 decoding failed. Input has a length of %zu (without"
-            " padding), which is invalid.\n",
-            len);
-    return 0;
-  }
-  return tuples * 3 + tail_xtra[tail_case];
-}
-
-bool grpc_base64_decode_partial(struct grpc_base64_decode_context* ctx) {
-  size_t input_tail;
-
-  if (ctx->input_cur > ctx->input_end || ctx->output_cur > ctx->output_end) {
-    return false;
-  }
-
-  // Process a block of 4 input characters and 3 output bytes
-  while (ctx->input_end >= ctx->input_cur + 4 &&
-         ctx->output_end >= ctx->output_cur + 3) {
-    if (!input_is_valid(ctx->input_cur, 4)) return false;
-    ctx->output_cur[0] = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur);
-    ctx->output_cur[1] = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur);
-    ctx->output_cur[2] = COMPOSE_OUTPUT_BYTE_2(ctx->input_cur);
-    ctx->output_cur += 3;
-    ctx->input_cur += 4;
-  }
-
-  // Process the tail of input data
-  input_tail = static_cast<size_t>(ctx->input_end - ctx->input_cur);
-  if (input_tail == 4) {
-    // Process the input data with pad chars
-    if (ctx->input_cur[3] == '=') {
-      if (ctx->input_cur[2] == '=' && ctx->output_end >= ctx->output_cur + 1) {
-        if (!input_is_valid(ctx->input_cur, 2)) return false;
-        *(ctx->output_cur++) = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur);
-        ctx->input_cur += 4;
-      } else if (ctx->output_end >= ctx->output_cur + 2) {
-        if (!input_is_valid(ctx->input_cur, 3)) return false;
-        *(ctx->output_cur++) = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur);
-        *(ctx->output_cur++) = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur);
-        ;
-        ctx->input_cur += 4;
-      }
-    }
-
-  } else if (ctx->contains_tail && input_tail > 1) {
-    // Process the input data without pad chars, but constains_tail is set
-    if (ctx->output_end >= ctx->output_cur + tail_xtra[input_tail]) {
-      if (!input_is_valid(ctx->input_cur, input_tail)) return false;
-      switch (input_tail) {
-        case 3:
-          ctx->output_cur[1] = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur);
-          ABSL_FALLTHROUGH_INTENDED;
-        case 2:
-          ctx->output_cur[0] = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur);
-      }
-      ctx->output_cur += tail_xtra[input_tail];
-      ctx->input_cur += input_tail;
-    }
-  }
-
-  return true;
-}
-
-grpc_slice grpc_chttp2_base64_decode(const grpc_slice& input) {
-  size_t input_length = GRPC_SLICE_LENGTH(input);
-  size_t output_length = input_length / 4 * 3;
-  struct grpc_base64_decode_context ctx;
-  grpc_slice output;
-
-  if (GPR_UNLIKELY(input_length % 4 != 0)) {
-    gpr_log(GPR_ERROR,
-            "Base64 decoding failed, input of "
-            "grpc_chttp2_base64_decode has a length of %d, which is not a "
-            "multiple of 4.\n",
-            static_cast<int>(input_length));
-    return grpc_empty_slice();
-  }
-
-  if (input_length > 0) {
-    const uint8_t* input_end = GRPC_SLICE_END_PTR(input);
-    if (*(--input_end) == '=') {
-      output_length--;
-      if (*(--input_end) == '=') {
-        output_length--;
-      }
-    }
-  }
-  output = GRPC_SLICE_MALLOC(output_length);
-
-  ctx.input_cur = GRPC_SLICE_START_PTR(input);
-  ctx.input_end = GRPC_SLICE_END_PTR(input);
-  ctx.output_cur = GRPC_SLICE_START_PTR(output);
-  ctx.output_end = GRPC_SLICE_END_PTR(output);
-  ctx.contains_tail = false;
-
-  if (GPR_UNLIKELY(!grpc_base64_decode_partial(&ctx))) {
-    char* s = grpc_slice_to_c_string(input);
-    gpr_log(GPR_ERROR, "Base64 decoding failed, input string:\n%s\n", s);
-    gpr_free(s);
-    grpc_core::CSliceUnref(output);
-    return grpc_empty_slice();
-  }
-  GPR_ASSERT(ctx.output_cur == GRPC_SLICE_END_PTR(output));
-  GPR_ASSERT(ctx.input_cur == GRPC_SLICE_END_PTR(input));
-  return output;
-}
-
-grpc_slice grpc_chttp2_base64_decode_with_length(const grpc_slice& input,
-                                                 size_t output_length) {
-  size_t input_length = GRPC_SLICE_LENGTH(input);
-  grpc_slice output = GRPC_SLICE_MALLOC(output_length);
-  struct grpc_base64_decode_context ctx;
-
-  // The length of a base64 string cannot be 4 * n + 1
-  if (GPR_UNLIKELY(input_length % 4 == 1)) {
-    gpr_log(GPR_ERROR,
-            "Base64 decoding failed, input of "
-            "grpc_chttp2_base64_decode_with_length has a length of %d, which "
-            "has a tail of 1 byte.\n",
-            static_cast<int>(input_length));
-    grpc_core::CSliceUnref(output);
-    return grpc_empty_slice();
-  }
-
-  if (GPR_UNLIKELY(output_length >
-                   input_length / 4 * 3 + tail_xtra[input_length % 4])) {
-    gpr_log(
-        GPR_ERROR,
-        "Base64 decoding failed, output_length %d is longer "
-        "than the max possible output length %d.\n",
-        static_cast<int>(output_length),
-        static_cast<int>(input_length / 4 * 3 + tail_xtra[input_length % 4]));
-    grpc_core::CSliceUnref(output);
-    return grpc_empty_slice();
-  }
-
-  ctx.input_cur = GRPC_SLICE_START_PTR(input);
-  ctx.input_end = GRPC_SLICE_END_PTR(input);
-  ctx.output_cur = GRPC_SLICE_START_PTR(output);
-  ctx.output_end = GRPC_SLICE_END_PTR(output);
-  ctx.contains_tail = true;
-
-  if (GPR_UNLIKELY(!grpc_base64_decode_partial(&ctx))) {
-    char* s = grpc_slice_to_c_string(input);
-    gpr_log(GPR_ERROR, "Base64 decoding failed, input string:\n%s\n", s);
-    gpr_free(s);
-    grpc_core::CSliceUnref(output);
-    return grpc_empty_slice();
-  }
-  GPR_ASSERT(ctx.output_cur == GRPC_SLICE_END_PTR(output));
-  GPR_ASSERT(ctx.input_cur <= GRPC_SLICE_END_PTR(input));
-  return output;
-}

data/src/core/ext/transport/chttp2/transport/bin_decoder.h

@@ -1,58 +0,0 @@
-/*
- *
- * Copyright 2016 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_DECODER_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_DECODER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <grpc/slice.h>
-
-struct grpc_base64_decode_context {
-  /* input/output: */
-  const uint8_t* input_cur;
-  const uint8_t* input_end;
-  uint8_t* output_cur;
-  uint8_t* output_end;
-  /* Indicate if the decoder should handle the tail of input data*/
-  bool contains_tail;
-};
-
-/* base64 decode a grpc_base64_decode_context util either input_end is reached
-   or output_end is reached. When input_end is reached, (input_end - input_cur)
-   is less than 4. When output_end is reached, (output_end - output_cur) is less
-   than 3. Returns false if decoding is failed. */
-bool grpc_base64_decode_partial(struct grpc_base64_decode_context* ctx);
-
-/* base64 decode a slice with pad chars. Returns a new slice, does not take
-   ownership of the input. Returns an empty slice if decoding is failed. */
-grpc_slice grpc_chttp2_base64_decode(const grpc_slice& input);
-
-/* base64 decode a slice without pad chars, data length is needed. Returns a new
-   slice, does not take ownership of the input. Returns an empty slice if
-   decoding is failed. */
-grpc_slice grpc_chttp2_base64_decode_with_length(const grpc_slice& input,
-                                                 size_t output_length);
-
-/* Infer the length of decoded data from encoded data. */
-size_t grpc_chttp2_base64_infer_length_after_decode(const grpc_slice& slice);
-
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_DECODER_H */

data/src/core/ext/transport/chttp2/transport/bin_encoder.cc

@@ -1,232 +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 "src/core/ext/transport/chttp2/transport/bin_encoder.h"
-
-#include <stdint.h>
-#include <string.h>
-
-#include <grpc/support/log.h>
-
-#include "src/core/ext/transport/chttp2/transport/huffsyms.h"
-
-static const char alphabet[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-struct b64_huff_sym {
-  uint16_t bits;
-  uint8_t length;
-};
-static const b64_huff_sym huff_alphabet[64] = {
-    {0x21, 6}, {0x5d, 7}, {0x5e, 7},   {0x5f, 7}, {0x60, 7}, {0x61, 7},
-    {0x62, 7}, {0x63, 7}, {0x64, 7},   {0x65, 7}, {0x66, 7}, {0x67, 7},
-    {0x68, 7}, {0x69, 7}, {0x6a, 7},   {0x6b, 7}, {0x6c, 7}, {0x6d, 7},
-    {0x6e, 7}, {0x6f, 7}, {0x70, 7},   {0x71, 7}, {0x72, 7}, {0xfc, 8},
-    {0x73, 7}, {0xfd, 8}, {0x3, 5},    {0x23, 6}, {0x4, 5},  {0x24, 6},
-    {0x5, 5},  {0x25, 6}, {0x26, 6},   {0x27, 6}, {0x6, 5},  {0x74, 7},
-    {0x75, 7}, {0x28, 6}, {0x29, 6},   {0x2a, 6}, {0x7, 5},  {0x2b, 6},
-    {0x76, 7}, {0x2c, 6}, {0x8, 5},    {0x9, 5},  {0x2d, 6}, {0x77, 7},
-    {0x78, 7}, {0x79, 7}, {0x7a, 7},   {0x7b, 7}, {0x0, 5},  {0x1, 5},
-    {0x2, 5},  {0x19, 6}, {0x1a, 6},   {0x1b, 6}, {0x1c, 6}, {0x1d, 6},
-    {0x1e, 6}, {0x1f, 6}, {0x7fb, 11}, {0x18, 6}};
-
-static const uint8_t tail_xtra[3] = {0, 2, 3};
-
-grpc_slice grpc_chttp2_base64_encode(const grpc_slice& input) {
-  size_t input_length = GRPC_SLICE_LENGTH(input);
-  size_t input_triplets = input_length / 3;
-  size_t tail_case = input_length % 3;
-  size_t output_length = input_triplets * 4 + tail_xtra[tail_case];
-  grpc_slice output = GRPC_SLICE_MALLOC(output_length);
-  const uint8_t* in = GRPC_SLICE_START_PTR(input);
-  char* out = reinterpret_cast<char*> GRPC_SLICE_START_PTR(output);
-  size_t i;
-
-  /* encode full triplets */
-  for (i = 0; i < input_triplets; i++) {
-    out[0] = alphabet[in[0] >> 2];
-    out[1] = alphabet[((in[0] & 0x3) << 4) | (in[1] >> 4)];
-    out[2] = alphabet[((in[1] & 0xf) << 2) | (in[2] >> 6)];
-    out[3] = alphabet[in[2] & 0x3f];
-    out += 4;
-    in += 3;
-  }
-
-  /* encode the remaining bytes */
-  switch (tail_case) {
-    case 0:
-      break;
-    case 1:
-      out[0] = alphabet[in[0] >> 2];
-      out[1] = alphabet[(in[0] & 0x3) << 4];
-      out += 2;
-      in += 1;
-      break;
-    case 2:
-      out[0] = alphabet[in[0] >> 2];
-      out[1] = alphabet[((in[0] & 0x3) << 4) | (in[1] >> 4)];
-      out[2] = alphabet[(in[1] & 0xf) << 2];
-      out += 3;
-      in += 2;
-      break;
-  }
-
-  GPR_ASSERT(out == (char*)GRPC_SLICE_END_PTR(output));
-  GPR_ASSERT(in == GRPC_SLICE_END_PTR(input));
-  return output;
-}
-
-grpc_slice grpc_chttp2_huffman_compress(const grpc_slice& input) {
-  size_t nbits;
-  const uint8_t* in;
-  uint8_t* out;
-  grpc_slice output;
-  uint64_t temp = 0;
-  uint32_t temp_length = 0;
-
-  nbits = 0;
-  for (in = GRPC_SLICE_START_PTR(input); in != GRPC_SLICE_END_PTR(input);
-       ++in) {
-    nbits += grpc_chttp2_huffsyms[*in].length;
-  }
-
-  output = GRPC_SLICE_MALLOC(nbits / 8 + (nbits % 8 != 0));
-  out = GRPC_SLICE_START_PTR(output);
-  for (in = GRPC_SLICE_START_PTR(input); in != GRPC_SLICE_END_PTR(input);
-       ++in) {
-    int sym = *in;
-    temp <<= grpc_chttp2_huffsyms[sym].length;
-    temp |= grpc_chttp2_huffsyms[sym].bits;
-    temp_length += grpc_chttp2_huffsyms[sym].length;
-
-    while (temp_length > 8) {
-      temp_length -= 8;
-      *out++ = static_cast<uint8_t>(temp >> temp_length);
-    }
-  }
-
-  if (temp_length) {
-    /* NB: the following integer arithmetic operation needs to be in its
-     * expanded form due to the "integral promotion" performed (see section
-     * 3.2.1.1 of the C89 draft standard). A cast to the smaller container type
-     * is then required to avoid the compiler warning */
-    *out++ =
-        static_cast<uint8_t>(static_cast<uint8_t>(temp << (8u - temp_length)) |
-                             static_cast<uint8_t>(0xffu >> temp_length));
-  }
-
-  GPR_ASSERT(out == GRPC_SLICE_END_PTR(output));
-
-  return output;
-}
-
-struct huff_out {
-  uint32_t temp;
-  uint32_t temp_length;
-  uint8_t* out;
-};
-static void enc_flush_some(huff_out* out) {
-  while (out->temp_length > 8) {
-    out->temp_length -= 8;
-    *out->out++ = static_cast<uint8_t>(out->temp >> out->temp_length);
-  }
-}
-
-static void enc_add2(huff_out* out, uint8_t a, uint8_t b) {
-  b64_huff_sym sa = huff_alphabet[a];
-  b64_huff_sym sb = huff_alphabet[b];
-  out->temp = (out->temp << (sa.length + sb.length)) |
-              (static_cast<uint32_t>(sa.bits) << sb.length) | sb.bits;
-  out->temp_length +=
-      static_cast<uint32_t>(sa.length) + static_cast<uint32_t>(sb.length);
-  enc_flush_some(out);
-}
-
-static void enc_add1(huff_out* out, uint8_t a) {
-  b64_huff_sym sa = huff_alphabet[a];
-  out->temp = (out->temp << sa.length) | sa.bits;
-  out->temp_length += sa.length;
-  enc_flush_some(out);
-}
-
-grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
-    const grpc_slice& input) {
-  size_t input_length = GRPC_SLICE_LENGTH(input);
-  size_t input_triplets = input_length / 3;
-  size_t tail_case = input_length % 3;
-  size_t output_syms = input_triplets * 4 + tail_xtra[tail_case];
-  size_t max_output_bits = 11 * output_syms;
-  size_t max_output_length = max_output_bits / 8 + (max_output_bits % 8 != 0);
-  grpc_slice output = GRPC_SLICE_MALLOC(max_output_length);
-  const uint8_t* in = GRPC_SLICE_START_PTR(input);
-  uint8_t* start_out = GRPC_SLICE_START_PTR(output);
-  huff_out out;
-  size_t i;
-
-  out.temp = 0;
-  out.temp_length = 0;
-  out.out = start_out;
-
-  /* encode full triplets */
-  for (i = 0; i < input_triplets; i++) {
-    const uint8_t low_to_high = static_cast<uint8_t>((in[0] & 0x3) << 4);
-    const uint8_t high_to_low = in[1] >> 4;
-    enc_add2(&out, in[0] >> 2, low_to_high | high_to_low);
-
-    const uint8_t a = static_cast<uint8_t>((in[1] & 0xf) << 2);
-    const uint8_t b = (in[2] >> 6);
-    enc_add2(&out, a | b, in[2] & 0x3f);
-    in += 3;
-  }
-
-  /* encode the remaining bytes */
-  switch (tail_case) {
-    case 0:
-      break;
-    case 1:
-      enc_add2(&out, in[0] >> 2, static_cast<uint8_t>((in[0] & 0x3) << 4));
-      in += 1;
-      break;
-    case 2: {
-      const uint8_t low_to_high = static_cast<uint8_t>((in[0] & 0x3) << 4);
-      const uint8_t high_to_low = in[1] >> 4;
-      enc_add2(&out, in[0] >> 2, low_to_high | high_to_low);
-      enc_add1(&out, static_cast<uint8_t>((in[1] & 0xf) << 2));
-      in += 2;
-      break;
-    }
-  }
-
-  if (out.temp_length) {
-    /* NB: the following integer arithmetic operation needs to be in its
-     * expanded form due to the "integral promotion" performed (see section
-     * 3.2.1.1 of the C89 draft standard). A cast to the smaller container type
-     * is then required to avoid the compiler warning */
-    *out.out++ = static_cast<uint8_t>(
-        static_cast<uint8_t>(out.temp << (8u - out.temp_length)) |
-        static_cast<uint8_t>(0xffu >> out.temp_length));
-  }
-
-  GPR_ASSERT(out.out <= GRPC_SLICE_END_PTR(output));
-  GRPC_SLICE_SET_LENGTH(output, out.out - start_out);
-
-  GPR_ASSERT(in == GRPC_SLICE_END_PTR(input));
-  return output;
-}

data/src/core/ext/transport/chttp2/transport/bin_encoder.h

@@ -1,42 +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_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_ENCODER_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_ENCODER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/slice.h>
-
-/* base64 encode a slice. Returns a new slice, does not take ownership of the
-   input */
-grpc_slice grpc_chttp2_base64_encode(const grpc_slice& input);
-
-/* Compress a slice with the static huffman encoder detailed in the hpack
-   standard. Returns a new slice, does not take ownership of the input */
-grpc_slice grpc_chttp2_huffman_compress(const grpc_slice& input);
-
-/* equivalent to:
-   grpc_slice x = grpc_chttp2_base64_encode(input);
-   grpc_slice y = grpc_chttp2_huffman_compress(x);
-   grpc_core::CSliceUnref( x);
-   return y; */
-grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
-    const grpc_slice& input);
-
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_ENCODER_H */