legacy-libs/grpc/deps/grpc/src/core/ext/transport/chttp2/transport/frame_settings.cc

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <grpc/support/port_platform.h>
  20
  21 #include "src/core/ext/transport/chttp2/transport/frame_settings.h"
  22 #include "src/core/ext/transport/chttp2/transport/internal.h"
  23
  24 #include <string.h>
  25
  26 #include <grpc/support/alloc.h>
  27 #include <grpc/support/log.h>
  28 #include <grpc/support/string_util.h>
  29
  30 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
  31 #include "src/core/ext/transport/chttp2/transport/frame.h"
  32 #include "src/core/lib/debug/trace.h"
  33 #include "src/core/lib/transport/http2_errors.h"
  34
  35 static uint8_t* fill_header(uint8_t* out, uint32_t length, uint8_t flags) {
  36   *out++ = static_cast<uint8_t>(length >> 16);
  37   *out++ = static_cast<uint8_t>(length >> 8);
  38   *out++ = static_cast<uint8_t>(length);
  39   *out++ = GRPC_CHTTP2_FRAME_SETTINGS;
  40   *out++ = flags;
  41   *out++ = 0;
  42   *out++ = 0;
  43   *out++ = 0;
  44   *out++ = 0;
  45   return out;
  46 }
  47
  48 grpc_slice grpc_chttp2_settings_create(uint32_t* old_settings,
  49                                        const uint32_t* new_settings,
  50                                        uint32_t force_mask, size_t count) {
  51   size_t i;
  52   uint32_t n = 0;
  53   grpc_slice output;
  54   uint8_t* p;
  55
  56   for (i = 0; i < count; i++) {
  57     n += (new_settings[i] != old_settings[i] || (force_mask & (1u << i)) != 0);
  58   }
  59
  60   output = GRPC_SLICE_MALLOC(9 + 6 * n);
  61   p = fill_header(GRPC_SLICE_START_PTR(output), 6 * n, 0);
  62
  63   for (i = 0; i < count; i++) {
  64     if (new_settings[i] != old_settings[i] || (force_mask & (1u << i)) != 0) {
  65       *p++ = static_cast<uint8_t>(grpc_setting_id_to_wire_id[i] >> 8);
  66       *p++ = static_cast<uint8_t>(grpc_setting_id_to_wire_id[i]);
  67       *p++ = static_cast<uint8_t>(new_settings[i] >> 24);
  68       *p++ = static_cast<uint8_t>(new_settings[i] >> 16);
  69       *p++ = static_cast<uint8_t>(new_settings[i] >> 8);
  70       *p++ = static_cast<uint8_t>(new_settings[i]);
  71       old_settings[i] = new_settings[i];
  72     }
  73   }
  74
  75   GPR_ASSERT(p == GRPC_SLICE_END_PTR(output));
  76
  77   return output;
  78 }
  79
  80 grpc_slice grpc_chttp2_settings_ack_create(void) {
  81   grpc_slice output = GRPC_SLICE_MALLOC(9);
  82   fill_header(GRPC_SLICE_START_PTR(output), 0, GRPC_CHTTP2_FLAG_ACK);
  83   return output;
  84 }
  85
  86 grpc_error* grpc_chttp2_settings_parser_begin_frame(
  87     grpc_chttp2_settings_parser* parser, uint32_t length, uint8_t flags,
  88     uint32_t* settings) {
  89   parser->target_settings = settings;
  90   memcpy(parser->incoming_settings, settings,
  91          GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
  92   parser->is_ack = 0;
  93   parser->state = GRPC_CHTTP2_SPS_ID0;
  94   if (flags == GRPC_CHTTP2_FLAG_ACK) {
  95     parser->is_ack = 1;
  96     if (length != 0) {
  97       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
  98           "non-empty settings ack frame received");
  99     }
 100     return GRPC_ERROR_NONE;
 101   } else if (flags != 0) {
 102     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
 103         "invalid flags on settings frame");
 104   } else if (length % 6 != 0) {
 105     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
 106         "settings frames must be a multiple of six bytes");
 107   } else {
 108     return GRPC_ERROR_NONE;
 109   }
 110 }
 111
 112 grpc_error* grpc_chttp2_settings_parser_parse(void* p, grpc_chttp2_transport* t,
 113                                               grpc_chttp2_stream* s,
 114                                               const grpc_slice& slice,
 115                                               int is_last) {
 116   grpc_chttp2_settings_parser* parser =
 117       static_cast<grpc_chttp2_settings_parser*>(p);
 118   const uint8_t* cur = GRPC_SLICE_START_PTR(slice);
 119   const uint8_t* end = GRPC_SLICE_END_PTR(slice);
 120   char* msg;
 121   grpc_chttp2_setting_id id;
 122
 123   if (parser->is_ack) {
 124     return GRPC_ERROR_NONE;
 125   }
 126
 127   for (;;) {
 128     switch (parser->state) {
 129       case GRPC_CHTTP2_SPS_ID0:
 130         if (cur == end) {
 131           parser->state = GRPC_CHTTP2_SPS_ID0;
 132           if (is_last) {
 133             memcpy(parser->target_settings, parser->incoming_settings,
 134                    GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
 135             t->num_pending_induced_frames++;
 136             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());
 137             if (t->notify_on_receive_settings != nullptr) {
 138               GRPC_CLOSURE_SCHED(t->notify_on_receive_settings,
 139                                  GRPC_ERROR_NONE);
 140               t->notify_on_receive_settings = nullptr;
 141             }
 142           }
 143           return GRPC_ERROR_NONE;
 144         }
 145         parser->id = static_cast<uint16_t>((static_cast<uint16_t>(*cur)) << 8);
 146         cur++;
 147       /* fallthrough */
 148       case GRPC_CHTTP2_SPS_ID1:
 149         if (cur == end) {
 150           parser->state = GRPC_CHTTP2_SPS_ID1;
 151           return GRPC_ERROR_NONE;
 152         }
 153         parser->id = static_cast<uint16_t>(parser->id | (*cur));
 154         cur++;
 155       /* fallthrough */
 156       case GRPC_CHTTP2_SPS_VAL0:
 157         if (cur == end) {
 158           parser->state = GRPC_CHTTP2_SPS_VAL0;
 159           return GRPC_ERROR_NONE;
 160         }
 161         parser->value = (static_cast<uint32_t>(*cur)) << 24;
 162         cur++;
 163       /* fallthrough */
 164       case GRPC_CHTTP2_SPS_VAL1:
 165         if (cur == end) {
 166           parser->state = GRPC_CHTTP2_SPS_VAL1;
 167           return GRPC_ERROR_NONE;
 168         }
 169         parser->value |= (static_cast<uint32_t>(*cur)) << 16;
 170         cur++;
 171       /* fallthrough */
 172       case GRPC_CHTTP2_SPS_VAL2:
 173         if (cur == end) {
 174           parser->state = GRPC_CHTTP2_SPS_VAL2;
 175           return GRPC_ERROR_NONE;
 176         }
 177         parser->value |= (static_cast<uint32_t>(*cur)) << 8;
 178         cur++;
 179       /* fallthrough */
 180       case GRPC_CHTTP2_SPS_VAL3:
 181         if (cur == end) {
 182           parser->state = GRPC_CHTTP2_SPS_VAL3;
 183           return GRPC_ERROR_NONE;
 184         } else {
 185           parser->state = GRPC_CHTTP2_SPS_ID0;
 186         }
 187         parser->value |= *cur;
 188         cur++;
 189
 190         if (grpc_wire_id_to_setting_id(parser->id, &id)) {
 191           const grpc_chttp2_setting_parameters* sp =
 192               &grpc_chttp2_settings_parameters[id];
 193           // If flow control is disabled we skip these.
 194           if (!t->flow_control->flow_control_enabled() &&
 195               (id == GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE ||
 196                id == GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE)) {
 197             continue;
 198           }
 199           if (parser->value < sp->min_value || parser->value > sp->max_value) {
 200             switch (sp->invalid_value_behavior) {
 201               case GRPC_CHTTP2_CLAMP_INVALID_VALUE:
 202                 parser->value =
 203                     GPR_CLAMP(parser->value, sp->min_value, sp->max_value);
 204                 break;
 205               case GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE:
 206                 grpc_chttp2_goaway_append(
 207                     t->last_new_stream_id, sp->error_value,
 208                     grpc_slice_from_static_string("HTTP2 settings error"),
 209                     &t->qbuf);
 210                 gpr_asprintf(&msg, "invalid value %u passed for %s",
 211                              parser->value, sp->name);
 212                 grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
 213                 gpr_free(msg);
 214                 return err;
 215             }
 216           }
 217           if (id == GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE &&
 218               parser->incoming_settings[id] != parser->value) {
 219             t->initial_window_update += static_cast<int64_t>(parser->value) -
 220                                         parser->incoming_settings[id];
 221             if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
 222                 GRPC_TRACE_FLAG_ENABLED(grpc_flowctl_trace)) {
 223               gpr_log(GPR_INFO, "%p[%s] adding %d for initial_window change", t,
 224                       t->is_client ? "cli" : "svr",
 225                       static_cast<int>(t->initial_window_update));
 226             }
 227           }
 228           parser->incoming_settings[id] = parser->value;
 229           if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
 230             gpr_log(GPR_INFO, "CHTTP2:%s:%s: got setting %s = %d",
 231                     t->is_client ? "CLI" : "SVR", t->peer_string, sp->name,
 232                     parser->value);
 233           }
 234         } else if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
 235           gpr_log(GPR_ERROR, "CHTTP2: Ignoring unknown setting %d (value %d)",
 236                   parser->id, parser->value);
 237         }
 238         break;
 239     }
 240   }
 241 }