C++ (Cpp) tsi_handshaker_get_bytes_to_send_to_peer示例

示例#1

文件： security_handshaker.c 项目： izouxv/grpc

static grpc_error *send_handshake_bytes_to_peer_locked(grpc_exec_ctx *exec_ctx,
                                                       security_handshaker *h) {
  // Get data to send.
  tsi_result result = TSI_OK;
  size_t offset = 0;
  do {
    size_t to_send_size = h->handshake_buffer_size - offset;
    result = tsi_handshaker_get_bytes_to_send_to_peer(
        h->handshaker, h->handshake_buffer + offset, &to_send_size);
    offset += to_send_size;
    if (result == TSI_INCOMPLETE_DATA) {
      h->handshake_buffer_size *= 2;
      h->handshake_buffer =
          gpr_realloc(h->handshake_buffer, h->handshake_buffer_size);
    }
  } while (result == TSI_INCOMPLETE_DATA);
  if (result != TSI_OK) {
    return grpc_set_tsi_error_result(GRPC_ERROR_CREATE("Handshake failed"),
                                     result);
  }
  // Send data.
  grpc_slice to_send =
      grpc_slice_from_copied_buffer((const char *)h->handshake_buffer, offset);
  grpc_slice_buffer_reset_and_unref(&h->outgoing);
  grpc_slice_buffer_add(&h->outgoing, to_send);
  grpc_endpoint_write(exec_ctx, h->args->endpoint, &h->outgoing,
                      &h->on_handshake_data_sent_to_peer);
  return GRPC_ERROR_NONE;
}

示例#2

文件： handshake.c 项目： nerdrew/grpc

static void send_handshake_bytes_to_peer(grpc_exec_ctx *exec_ctx,
        grpc_security_handshake *h) {
    size_t offset = 0;
    tsi_result result = TSI_OK;
    gpr_slice to_send;

    do {
        size_t to_send_size = h->handshake_buffer_size - offset;
        result = tsi_handshaker_get_bytes_to_send_to_peer(
                     h->handshaker, h->handshake_buffer + offset, &to_send_size);
        offset += to_send_size;
        if (result == TSI_INCOMPLETE_DATA) {
            h->handshake_buffer_size *= 2;
            h->handshake_buffer =
                gpr_realloc(h->handshake_buffer, h->handshake_buffer_size);
        }
    } while (result == TSI_INCOMPLETE_DATA);

    if (result != TSI_OK) {
        security_handshake_done(exec_ctx, h,
                                grpc_set_tsi_error_result(
                                    GRPC_ERROR_CREATE("Handshake failed"), result));
        return;
    }

    to_send =
        gpr_slice_from_copied_buffer((const char *)h->handshake_buffer, offset);
    gpr_slice_buffer_reset_and_unref(&h->outgoing);
    gpr_slice_buffer_add(&h->outgoing, to_send);
    /* TODO(klempner,jboeuf): This should probably use the client setup
       deadline */
    grpc_endpoint_write(exec_ctx, h->wrapped_endpoint, &h->outgoing,
                        &h->on_handshake_data_sent_to_peer);
}

示例#3

文件： transport_security_test.c 项目： 201528013359030/grpc

static void test_handshaker_invalid_args(void) {
  GPR_ASSERT(tsi_handshaker_get_result(NULL) == TSI_INVALID_ARGUMENT);
  GPR_ASSERT(tsi_handshaker_extract_peer(NULL, NULL) == TSI_INVALID_ARGUMENT);
  GPR_ASSERT(tsi_handshaker_create_frame_protector(NULL, NULL, NULL) ==
             TSI_INVALID_ARGUMENT);
  GPR_ASSERT(tsi_handshaker_process_bytes_from_peer(NULL, NULL, NULL) ==
             TSI_INVALID_ARGUMENT);
  GPR_ASSERT(tsi_handshaker_get_bytes_to_send_to_peer(NULL, NULL, NULL) ==
             TSI_INVALID_ARGUMENT);
}

示例#4

文件： secure_transport_setup.c 项目： AddictXQ/grpc

static void send_handshake_bytes_to_peer(grpc_secure_transport_setup *s) {
  size_t offset = 0;
  tsi_result result = TSI_OK;
  gpr_slice to_send;
  grpc_endpoint_write_status write_status;

  do {
    size_t to_send_size = s->handshake_buffer_size - offset;
    result = tsi_handshaker_get_bytes_to_send_to_peer(
        s->handshaker, s->handshake_buffer + offset, &to_send_size);
    offset += to_send_size;
    if (result == TSI_INCOMPLETE_DATA) {
      s->handshake_buffer_size *= 2;
      s->handshake_buffer =
          gpr_realloc(s->handshake_buffer, s->handshake_buffer_size);
    }
  } while (result == TSI_INCOMPLETE_DATA);

  if (result != TSI_OK) {
    gpr_log(GPR_ERROR, "Handshake failed with error %s",
            tsi_result_to_string(result));
    secure_transport_setup_done(s, 0);
    return;
  }

  to_send =
      gpr_slice_from_copied_buffer((const char *)s->handshake_buffer, offset);
  /* TODO(klempner,jboeuf): This should probably use the client setup
         deadline */
  write_status = grpc_endpoint_write(s->endpoint, &to_send, 1,
                                     on_handshake_data_sent_to_peer, s);
  if (write_status == GRPC_ENDPOINT_WRITE_ERROR) {
    gpr_log(GPR_ERROR, "Could not send handshake data to peer.");
    secure_transport_setup_done(s, 0);
  } else if (write_status == GRPC_ENDPOINT_WRITE_DONE) {
    on_handshake_data_sent_to_peer(s, GRPC_ENDPOINT_CB_OK);
  }
}