自学教程：C++ GPR_SLICE_LENGTH函数代码示例

static void recv_metadata(grpc_call *call, grpc_metadata_batch *md) {  grpc_linked_mdelem *l;  grpc_metadata_array *dest;  grpc_metadata *mdusr;  int is_trailing;  grpc_mdctx *mdctx = call->metadata_context;  is_trailing = call->read_state >= READ_STATE_GOT_INITIAL_METADATA;  for (l = md->list.head; l != NULL; l = l->next) {    grpc_mdelem *md = l->md;    grpc_mdstr *key = md->key;    if (key == grpc_channel_get_status_string(call->channel)) {      set_status_code(call, STATUS_FROM_WIRE, decode_status(md));    } else if (key == grpc_channel_get_message_string(call->channel)) {      set_status_details(call, STATUS_FROM_WIRE, grpc_mdstr_ref(md->value));    } else {      dest = &call->buffered_metadata[is_trailing];      if (dest->count == dest->capacity) {        dest->capacity = GPR_MAX(dest->capacity + 8, dest->capacity * 2);        dest->metadata =            gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity);      }      mdusr = &dest->metadata[dest->count++];      mdusr->key = grpc_mdstr_as_c_string(md->key);      mdusr->value = grpc_mdstr_as_c_string(md->value);      mdusr->value_length = GPR_SLICE_LENGTH(md->value->slice);      if (call->owned_metadata_count == call->owned_metadata_capacity) {        call->owned_metadata_capacity =            GPR_MAX(call->owned_metadata_capacity + 8,                    call->owned_metadata_capacity * 2);        call->owned_metadata =            gpr_realloc(call->owned_metadata,                        sizeof(grpc_mdelem *) * call->owned_metadata_capacity);      }      call->owned_metadata[call->owned_metadata_count++] = md;      l->md = 0;    }  }  if (gpr_time_cmp(md->deadline, gpr_inf_future) != 0) {    set_deadline_alarm(call, md->deadline);  }  if (!is_trailing) {    call->read_state = READ_STATE_GOT_INITIAL_METADATA;  }  grpc_mdctx_lock(mdctx);  for (l = md->list.head; l; l = l->next) {    if (l->md) grpc_mdctx_locked_mdelem_unref(mdctx, l->md);  }  for (l = md->garbage.head; l; l = l->next) {    grpc_mdctx_locked_mdelem_unref(mdctx, l->md);  }  grpc_mdctx_unlock(mdctx);}

int grpc_http_parser_parse(grpc_http_parser *parser, gpr_slice slice) {  size_t i;  for (i = 0; i < GPR_SLICE_LENGTH(slice); i++) {    if (!addbyte(parser, GPR_SLICE_START_PTR(slice)[i])) {      return 0;    }  }  return 1;}

static void win_notify_on_read(grpc_endpoint *ep,                               grpc_endpoint_read_cb cb, void *arg) {  grpc_tcp *tcp = (grpc_tcp *) ep;  grpc_winsocket *handle = tcp->socket;  grpc_winsocket_callback_info *info = &handle->read_info;  int status;  DWORD bytes_read = 0;  DWORD flags = 0;  WSABUF buffer;  GPR_ASSERT(!tcp->socket->read_info.outstanding);  if (tcp->shutting_down) {    cb(arg, NULL, 0, GRPC_ENDPOINT_CB_SHUTDOWN);    return;  }  tcp_ref(tcp);  tcp->socket->read_info.outstanding = 1;  tcp->read_cb = cb;  tcp->read_user_data = arg;  tcp->read_slice = gpr_slice_malloc(8192);  buffer.len = GPR_SLICE_LENGTH(tcp->read_slice);  buffer.buf = (char *)GPR_SLICE_START_PTR(tcp->read_slice);  /* First let's try a synchronous, non-blocking read. */  status = WSARecv(tcp->socket->socket, &buffer, 1, &bytes_read, &flags,                   NULL, NULL);  info->wsa_error = status == 0 ? 0 : WSAGetLastError();  /* Did we get data immediately ? Yay. */  if (info->wsa_error != WSAEWOULDBLOCK) {    info->bytes_transfered = bytes_read;    /* This might heavily recurse. */    on_read(tcp, 1);    return;  }  /* Otherwise, let's retry, by queuing a read. */  memset(&tcp->socket->read_info.overlapped, 0, sizeof(OVERLAPPED));  status = WSARecv(tcp->socket->socket, &buffer, 1, &bytes_read, &flags,                   &info->overlapped, NULL);  if (status != 0) {    int wsa_error = WSAGetLastError();    if (wsa_error != WSA_IO_PENDING) {      info->wsa_error = wsa_error;      on_read(tcp, 1);      return;    }  }  grpc_socket_notify_on_read(tcp->socket, on_read, tcp);}

static gpr_slice merge_slices(gpr_slice *slices, size_t nslices) {  size_t i;  size_t len = 0;  uint8_t *cursor;  gpr_slice out;  for (i = 0; i < nslices; i++) {    len += GPR_SLICE_LENGTH(slices[i]);  }  out = gpr_slice_malloc(len);  cursor = GPR_SLICE_START_PTR(out);  for (i = 0; i < nslices; i++) {    memcpy(cursor, GPR_SLICE_START_PTR(slices[i]), GPR_SLICE_LENGTH(slices[i]));    cursor += GPR_SLICE_LENGTH(slices[i]);  }  return out;}

static void test_bad_audience_claims_failure(void) {  grpc_jwt_claims *claims;  gpr_slice s = gpr_slice_from_copied_string(claims_without_time_constraint);  grpc_json *json = grpc_json_parse_string_with_len(      (char *)GPR_SLICE_START_PTR(s), GPR_SLICE_LENGTH(s));  GPR_ASSERT(json != NULL);  claims = grpc_jwt_claims_from_json(json, s);  GPR_ASSERT(claims != NULL);  GPR_ASSERT(grpc_jwt_claims_check(claims, "https://bar.com") ==             GRPC_JWT_VERIFIER_BAD_AUDIENCE);  grpc_jwt_claims_destroy(claims);}

static grpc_json *parse_json_part_from_jwt(const char *str, size_t len,                                           char **scratchpad) {  char *b64;  char *decoded;  grpc_json *json;  gpr_slice slice;  b64 = gpr_malloc(len + 1);  strncpy(b64, str, len);  b64[len] = '/0';  slice = grpc_base64_decode(b64, 1);  GPR_ASSERT(!GPR_SLICE_IS_EMPTY(slice));  decoded = gpr_malloc(GPR_SLICE_LENGTH(slice) + 1);  strncpy(decoded, (const char *)GPR_SLICE_START_PTR(slice),          GPR_SLICE_LENGTH(slice));  decoded[GPR_SLICE_LENGTH(slice)] = '/0';  json = grpc_json_parse_string(decoded);  gpr_free(b64);  *scratchpad = decoded;  gpr_slice_unref(slice);  return json;}

static void on_oauth2_response(void *user_data, grpc_credentials_md *md_elems,                               size_t num_md, grpc_credentials_status status) {  oauth2_request *request = user_data;  char *token = NULL;  gpr_slice token_slice;  if (status == GRPC_CREDENTIALS_ERROR) {    gpr_log(GPR_ERROR, "Fetching token failed.");  } else {    GPR_ASSERT(num_md == 1);    token_slice = md_elems[0].value;    token = gpr_malloc(GPR_SLICE_LENGTH(token_slice) + 1);    memcpy(token, GPR_SLICE_START_PTR(token_slice),           GPR_SLICE_LENGTH(token_slice));    token[GPR_SLICE_LENGTH(token_slice)] = '/0';  }  gpr_mu_lock(GRPC_POLLSET_MU(&request->pollset));  request->is_done = 1;  request->token = token;  grpc_pollset_kick(&request->pollset);  gpr_mu_unlock(GRPC_POLLSET_MU(&request->pollset));}

size_t gpr_slice_buffer_add_indexed(gpr_slice_buffer *sb, gpr_slice s) {  size_t out = sb->count;  if (out == sb->capacity) {    sb->capacity = GROW(sb->capacity);    GPR_ASSERT(sb->capacity > sb->count);    sb->slices = gpr_realloc(sb->slices, sb->capacity * sizeof(gpr_slice));  }  sb->slices[out] = s;  sb->length += GPR_SLICE_LENGTH(s);  sb->count = out + 1;  return out;}

static grpc_mdelem *remove_consumed_md(void *user_data, grpc_mdelem *md) {  grpc_call_element *elem = user_data;  call_data *calld = elem->call_data;  size_t i;  for (i = 0; i < calld->num_consumed_md; i++) {    const grpc_metadata *consumed_md = &calld->consumed_md[i];    /* Maybe we could do a pointer comparison but we do not have any guarantee       that the metadata processor used the same pointers for consumed_md in the       callback. */    if (GPR_SLICE_LENGTH(md->key->slice) != strlen(consumed_md->key) ||        GPR_SLICE_LENGTH(md->value->slice) != consumed_md->value_length) {      continue;    }    if (memcmp(GPR_SLICE_START_PTR(md->key->slice), consumed_md->key,               GPR_SLICE_LENGTH(md->key->slice)) == 0 &&        memcmp(GPR_SLICE_START_PTR(md->value->slice), consumed_md->value,               GPR_SLICE_LENGTH(md->value->slice)) == 0) {      return NULL; /* Delete. */    }  }  return md;}

void grpc_chttp2_add_incoming_goaway(    grpc_chttp2_transport_global *transport_global, gpr_uint32 goaway_error,    gpr_slice goaway_text) {  char *msg = gpr_hexdump((char*)GPR_SLICE_START_PTR(goaway_text), GPR_SLICE_LENGTH(goaway_text), GPR_HEXDUMP_PLAINTEXT);  gpr_free(msg);  if (transport_global->goaway_state == GRPC_CHTTP2_ERROR_STATE_NONE) {    transport_global->goaway_state = GRPC_CHTTP2_ERROR_STATE_SEEN;    transport_global->goaway_text = goaway_text;    transport_global->goaway_error = goaway_error;  } else {    gpr_slice_unref(goaway_text);  }}

static gpr_slice *allocate_blocks(ssize_t num_bytes, ssize_t slice_size,                                  size_t *num_blocks, int *current_data) {  size_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1 : 0);  gpr_slice *slices = gpr_malloc(sizeof(gpr_slice) * nslices);  ssize_t num_bytes_left = num_bytes;  unsigned i, j;  unsigned char *buf;  *num_blocks = nslices;  for (i = 0; i < nslices; ++i) {    slices[i] = gpr_slice_malloc(slice_size > num_bytes_left ? num_bytes_left                                                             : slice_size);    num_bytes_left -= GPR_SLICE_LENGTH(slices[i]);    buf = GPR_SLICE_START_PTR(slices[i]);    for (j = 0; j < GPR_SLICE_LENGTH(slices[i]); ++j) {      buf[j] = *current_data;      *current_data = (*current_data + 1) % 256;    }  }  GPR_ASSERT(num_bytes_left == 0);  return slices;}

static void expect_combined_equiv(const char *s, size_t len, int line) {  gpr_slice input = gpr_slice_from_copied_buffer(s, len);  gpr_slice base64 = grpc_chttp2_base64_encode(input);  gpr_slice expect = grpc_chttp2_huffman_compress(base64);  gpr_slice got = grpc_chttp2_base64_encode_and_huffman_compress(input);  if (0 != gpr_slice_cmp(expect, got)) {    char *t = gpr_hexdump((const char *)GPR_SLICE_START_PTR(input),                          GPR_SLICE_LENGTH(input), GPR_HEXDUMP_PLAINTEXT);    char *e = gpr_hexdump((const char *)GPR_SLICE_START_PTR(expect),                          GPR_SLICE_LENGTH(expect), GPR_HEXDUMP_PLAINTEXT);    char *g = gpr_hexdump((const char *)GPR_SLICE_START_PTR(got),                          GPR_SLICE_LENGTH(got), GPR_HEXDUMP_PLAINTEXT);    gpr_log(GPR_ERROR, "FAILED:%d:/ntest: %s/ngot:  %s/nwant: %s", t, g, e);    gpr_free(t);    gpr_free(e);    gpr_free(g);    all_ok = 0;  }  gpr_slice_unref(input);  gpr_slice_unref(base64);  gpr_slice_unref(expect);  gpr_slice_unref(got);}

static BIGNUM *bignum_from_base64(const char *b64) {  BIGNUM *result = NULL;  gpr_slice bin;  if (b64 == NULL) return NULL;  bin = grpc_base64_decode(b64, 1);  if (GPR_SLICE_IS_EMPTY(bin)) {    gpr_log(GPR_ERROR, "Invalid base64 for big num.");    return NULL;  }  result = BN_bin2bn(GPR_SLICE_START_PTR(bin), GPR_SLICE_LENGTH(bin), NULL);  gpr_slice_unref(bin);  return result;}

void gpr_slice_buffer_move_first(gpr_slice_buffer *src, size_t n,                                 gpr_slice_buffer *dst) {  size_t src_idx;  size_t output_len = dst->length + n;  size_t new_input_len = src->length - n;  GPR_ASSERT(src->length >= n);  if (src->length == n) {    gpr_slice_buffer_move_into(src, dst);    return;  }  src_idx = 0;  while (src_idx < src->capacity) {    gpr_slice slice = src->slices[src_idx];    size_t slice_len = GPR_SLICE_LENGTH(slice);    if (n > slice_len) {      gpr_slice_buffer_add(dst, slice);      n -= slice_len;      src_idx++;    } else if (n == slice_len) {      gpr_slice_buffer_add(dst, slice);      src_idx++;      break;    } else { /* n < slice_len */      src->slices[src_idx] = gpr_slice_split_tail(&slice, n);      GPR_ASSERT(GPR_SLICE_LENGTH(slice) == n);      GPR_ASSERT(GPR_SLICE_LENGTH(src->slices[src_idx]) == slice_len - n);      gpr_slice_buffer_add(dst, slice);      break;    }  }  GPR_ASSERT(dst->length == output_len);  memmove(src->slices, src->slices + src_idx,          sizeof(gpr_slice) * (src->count - src_idx));  src->count -= src_idx;  src->length = new_input_len;  GPR_ASSERT(src->count > 0);}

void grpc_chttp2_goaway_append(uint32_t last_stream_id, uint32_t error_code,                               gpr_slice debug_data,                               gpr_slice_buffer *slice_buffer) {  gpr_slice header = gpr_slice_malloc(9 + 4 + 4);  uint8_t *p = GPR_SLICE_START_PTR(header);  uint32_t frame_length;  GPR_ASSERT(GPR_SLICE_LENGTH(debug_data) < UINT32_MAX - 4 - 4);  frame_length = 4 + 4 + (uint32_t)GPR_SLICE_LENGTH(debug_data);  /* frame header: length */  *p++ = (uint8_t)(frame_length >> 16);  *p++ = (uint8_t)(frame_length >> 8);  *p++ = (uint8_t)(frame_length);  /* frame header: type */  *p++ = GRPC_CHTTP2_FRAME_GOAWAY;  /* frame header: flags */  *p++ = 0;  /* frame header: stream id */  *p++ = 0;  *p++ = 0;  *p++ = 0;  *p++ = 0;  /* payload: last stream id */  *p++ = (uint8_t)(last_stream_id >> 24);  *p++ = (uint8_t)(last_stream_id >> 16);  *p++ = (uint8_t)(last_stream_id >> 8);  *p++ = (uint8_t)(last_stream_id);  /* payload: error code */  *p++ = (uint8_t)(error_code >> 24);  *p++ = (uint8_t)(error_code >> 16);  *p++ = (uint8_t)(error_code >> 8);  *p++ = (uint8_t)(error_code);  GPR_ASSERT(p == GPR_SLICE_END_PTR(header));  gpr_slice_buffer_add(slice_buffer, header);  gpr_slice_buffer_add(slice_buffer, debug_data);}

static void check_jwt_signature(const char *b64_signature, RSA *rsa_key,                                const char *signed_data,                                size_t signed_data_size) {  EVP_MD_CTX *md_ctx = EVP_MD_CTX_create();  EVP_PKEY *key = EVP_PKEY_new();  gpr_slice sig = grpc_base64_decode(b64_signature, 1);  GPR_ASSERT(!GPR_SLICE_IS_EMPTY(sig));  GPR_ASSERT(GPR_SLICE_LENGTH(sig) == 128);  GPR_ASSERT(md_ctx != NULL);  GPR_ASSERT(key != NULL);  EVP_PKEY_set1_RSA(key, rsa_key);  GPR_ASSERT(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, key) == 1);  GPR_ASSERT(EVP_DigestVerifyUpdate(md_ctx, signed_data, signed_data_size) ==             1);  GPR_ASSERT(EVP_DigestVerifyFinal(md_ctx, GPR_SLICE_START_PTR(sig),                                   GPR_SLICE_LENGTH(sig)) == 1);  gpr_slice_unref(sig);  if (key != NULL) EVP_PKEY_free(key);  if (md_ctx != NULL) EVP_MD_CTX_destroy(md_ctx);}

/* verify that the output generated by encoding the stream matches the   hexstring passed in */static void verify_sopb(size_t window_available, int eof,                        size_t expect_window_used, const char *expected) {  gpr_slice_buffer output;  grpc_stream_op_buffer encops;  gpr_slice merged;  gpr_slice expect = parse_hexstring(expected);  gpr_slice_buffer_init(&output);  grpc_sopb_init(&encops);  GPR_ASSERT(expect_window_used ==             grpc_chttp2_preencode(g_sopb.ops, &g_sopb.nops, window_available,                                   &encops));  grpc_chttp2_encode(encops.ops, encops.nops, eof, 0xdeadbeef, &g_compressor,                     &output);  encops.nops = 0;  merged = grpc_slice_merge(output.slices, output.count);  gpr_slice_buffer_destroy(&output);  grpc_sopb_destroy(&encops);  if (0 != gpr_slice_cmp(merged, expect)) {    char *expect_str =        gpr_hexdump((char *)GPR_SLICE_START_PTR(expect),                    GPR_SLICE_LENGTH(expect), GPR_HEXDUMP_PLAINTEXT);    char *got_str =        gpr_hexdump((char *)GPR_SLICE_START_PTR(merged),                    GPR_SLICE_LENGTH(merged), GPR_HEXDUMP_PLAINTEXT);    gpr_log(GPR_ERROR, "mismatched output for %s", expected);    gpr_log(GPR_ERROR, "EXPECT: %s", expect_str);    gpr_log(GPR_ERROR, "GOT:    %s", got_str);    gpr_free(expect_str);    gpr_free(got_str);    g_failure = 1;  }  gpr_slice_unref(merged);  gpr_slice_unref(expect);}

static void assert_read_ok(call_state *s, grpc_byte_buffer *b) {  grpc_byte_buffer_reader *bb_reader = NULL;  gpr_slice read_slice;  unsigned i;  bb_reader = grpc_byte_buffer_reader_create(b);  while (grpc_byte_buffer_reader_next(bb_reader, &read_slice)) {    for (i = 0; i < GPR_SLICE_LENGTH(read_slice); i++) {      GPR_ASSERT(GPR_SLICE_START_PTR(read_slice)[i] == s->bytes_read % 256);      s->bytes_read++;    }    gpr_slice_unref(read_slice);  }  grpc_byte_buffer_reader_destroy(bb_reader);}

gpr_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader *reader) {  gpr_slice in_slice;  size_t bytes_read = 0;  const size_t input_size = grpc_byte_buffer_length(reader->buffer_out);  gpr_slice out_slice = gpr_slice_malloc(input_size);  uint8_t *const outbuf = GPR_SLICE_START_PTR(out_slice); /* just an alias */  while (grpc_byte_buffer_reader_next(reader, &in_slice) != 0) {    const size_t slice_length = GPR_SLICE_LENGTH(in_slice);    memcpy(&(outbuf[bytes_read]), GPR_SLICE_START_PTR(in_slice), slice_length);    bytes_read += slice_length;    gpr_slice_unref(in_slice);    GPR_ASSERT(bytes_read <= input_size);  }  return out_slice;}

static void emit_lithdr_noidx(grpc_chttp2_hpack_compressor *c,                              uint32_t key_index, grpc_mdelem *elem,                              framer_state *st) {  uint32_t len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 4);  uint8_t huffman_prefix;  gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);  size_t len_val = GPR_SLICE_LENGTH(value_slice);  uint32_t len_val_len;  GPR_ASSERT(len_val <= UINT32_MAX);  len_val_len = GRPC_CHTTP2_VARINT_LENGTH((uint32_t)len_val, 1);  GRPC_CHTTP2_WRITE_VARINT(key_index, 4, 0x00,                           add_tiny_header_data(st, len_pfx), len_pfx);  GRPC_CHTTP2_WRITE_VARINT((uint32_t)len_val, 1, huffman_prefix,                           add_tiny_header_data(st, len_val_len), len_val_len);  add_header_data(st, gpr_slice_ref(value_slice));}

static gpr_uint32 decode_status(grpc_mdelem *md) {  gpr_uint32 status;  void *user_data = grpc_mdelem_get_user_data(md, destroy_status);  if (user_data) {    status = ((gpr_uint32)(gpr_intptr) user_data) - STATUS_OFFSET;  } else {    if (!gpr_parse_bytes_to_uint32(grpc_mdstr_as_c_string(md->value),                                   GPR_SLICE_LENGTH(md->value->slice),                                   &status)) {      status = GRPC_STATUS_UNKNOWN; /* could not parse status code */    }    grpc_mdelem_set_user_data(md, destroy_status,                              (void *)(gpr_intptr)(status + STATUS_OFFSET));  }  return status;}

static void corrupt_jwt_sig(char *jwt) {  gpr_slice sig;  char *bad_b64_sig;  uint8_t *sig_bytes;  char *last_dot = strrchr(jwt, '.');  GPR_ASSERT(last_dot != NULL);  sig = grpc_base64_decode(last_dot + 1, 1);  GPR_ASSERT(!GPR_SLICE_IS_EMPTY(sig));  sig_bytes = GPR_SLICE_START_PTR(sig);  (*sig_bytes)++; /* Corrupt first byte. */  bad_b64_sig =      grpc_base64_encode(GPR_SLICE_START_PTR(sig), GPR_SLICE_LENGTH(sig), 1, 0);  memcpy(last_dot + 1, bad_b64_sig, strlen(bad_b64_sig));  gpr_free(bad_b64_sig);  gpr_slice_unref(sig);}

static void test_claims_success(void) {  grpc_jwt_claims *claims;  gpr_slice s = gpr_slice_from_copied_string(claims_without_time_constraint);  grpc_json *json = grpc_json_parse_string_with_len(      (char *)GPR_SLICE_START_PTR(s), GPR_SLICE_LENGTH(s));  GPR_ASSERT(json != NULL);  claims = grpc_jwt_claims_from_json(json, s);  GPR_ASSERT(claims != NULL);  GPR_ASSERT(grpc_jwt_claims_json(claims) == json);  GPR_ASSERT(strcmp(grpc_jwt_claims_audience(claims), "https://foo.com") == 0);  GPR_ASSERT(strcmp(grpc_jwt_claims_issuer(claims), "blah.foo.com") == 0);  GPR_ASSERT(strcmp(grpc_jwt_claims_subject(claims), "[email
C++ GPR_SLICE_START_PTR函数代码示例
C++ GPR_MAX函数代码示例