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

static gpr_slice compute_default_pem_root_certs_once(void) {  gpr_slice result = gpr_empty_slice();  /* First try to load the roots from the environment. */  char *default_root_certs_path =      gpr_getenv(GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR);  if (default_root_certs_path != NULL) {    GRPC_LOG_IF_ERROR("load_file",                      grpc_load_file(default_root_certs_path, 0, &result));    gpr_free(default_root_certs_path);  }  /* Try overridden roots if needed. */  grpc_ssl_roots_override_result ovrd_res = GRPC_SSL_ROOTS_OVERRIDE_FAIL;  if (GPR_SLICE_IS_EMPTY(result) && ssl_roots_override_cb != NULL) {    char *pem_root_certs = NULL;    ovrd_res = ssl_roots_override_cb(&pem_root_certs);    if (ovrd_res == GRPC_SSL_ROOTS_OVERRIDE_OK) {      GPR_ASSERT(pem_root_certs != NULL);      result = gpr_slice_new(pem_root_certs, strlen(pem_root_certs), gpr_free);    }  }  /* Fall back to installed certs if needed. */  if (GPR_SLICE_IS_EMPTY(result) &&      ovrd_res != GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY) {    GRPC_LOG_IF_ERROR("load_file",                      grpc_load_file(installed_roots_path, 0, &result));  }  return result;}

static void plugin_md_request_metadata_ready(void *request,                                             const grpc_metadata *md,                                             size_t num_md,                                             grpc_status_code status,                                             const char *error_details) {  /* called from application code */  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INITIALIZER(      GRPC_EXEC_CTX_FLAG_IS_FINISHED | GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP,      NULL, NULL);  grpc_metadata_plugin_request *r = (grpc_metadata_plugin_request *)request;  if (status != GRPC_STATUS_OK) {    if (error_details != NULL) {      gpr_log(GPR_ERROR, "Getting metadata from plugin failed with error: %s",              error_details);    }    r->cb(&exec_ctx, r->user_data, NULL, 0, GRPC_CREDENTIALS_ERROR,          error_details);  } else {    size_t i;    bool seen_illegal_header = false;    grpc_credentials_md *md_array = NULL;    for (i = 0; i < num_md; i++) {      if (!GRPC_LOG_IF_ERROR("validate_metadata_from_plugin",                             grpc_validate_header_key_is_legal(md[i].key))) {        seen_illegal_header = true;        break;      } else if (!grpc_is_binary_header(md[i].key) &&                 !GRPC_LOG_IF_ERROR(                     "validate_metadata_from_plugin",                     grpc_validate_header_nonbin_value_is_legal(md[i].value))) {        gpr_log(GPR_ERROR, "Plugin added invalid metadata value.");        seen_illegal_header = true;        break;      }    }    if (seen_illegal_header) {      r->cb(&exec_ctx, r->user_data, NULL, 0, GRPC_CREDENTIALS_ERROR,            "Illegal metadata");    } else if (num_md > 0) {      md_array = gpr_malloc(num_md * sizeof(grpc_credentials_md));      for (i = 0; i < num_md; i++) {        md_array[i].key = grpc_slice_ref_internal(md[i].key);        md_array[i].value = grpc_slice_ref_internal(md[i].value);      }      r->cb(&exec_ctx, r->user_data, md_array, num_md, GRPC_CREDENTIALS_OK,            NULL);      for (i = 0; i < num_md; i++) {        grpc_slice_unref_internal(&exec_ctx, md_array[i].key);        grpc_slice_unref_internal(&exec_ctx, md_array[i].value);      }      gpr_free(md_array);    } else if (num_md == 0) {      r->cb(&exec_ctx, r->user_data, NULL, 0, GRPC_CREDENTIALS_OK, NULL);    }  }  gpr_free(r);  grpc_exec_ctx_finish(&exec_ctx);}

// Simple gRPC server. This listens until client_handshake_complete occurs.static void server_thread(void *arg) {  const int port = *(int *)arg;  // Load key pair and establish server SSL credentials.  grpc_ssl_pem_key_cert_pair pem_key_cert_pair;  gpr_slice ca_slice, cert_slice, key_slice;  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",                               grpc_load_file(SSL_CA_PATH, 1, &ca_slice)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",                               grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",                               grpc_load_file(SSL_KEY_PATH, 1, &key_slice)));  const char *ca_cert = (const char *)GPR_SLICE_START_PTR(ca_slice);  pem_key_cert_pair.private_key = (const char *)GPR_SLICE_START_PTR(key_slice);  pem_key_cert_pair.cert_chain = (const char *)GPR_SLICE_START_PTR(cert_slice);  grpc_server_credentials *ssl_creds = grpc_ssl_server_credentials_create(      ca_cert, &pem_key_cert_pair, 1, 0, NULL);  // Start server listening on local port.  char *addr;  gpr_asprintf(&addr, "127.0.0.1:%d", port);  grpc_server *server = grpc_server_create(NULL, NULL);  GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));  free(addr);  grpc_completion_queue *cq = grpc_completion_queue_create(NULL);  grpc_server_register_completion_queue(server, cq, NULL);  grpc_server_start(server);  // Wait a bounded number of time until client_handshake_complete is set,  // sleeping between polls.  int retries = 10;  while (!gpr_event_get(&client_handshake_complete) && retries-- > 0) {    const gpr_timespec cq_deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1);    grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, NULL);    GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);  }  gpr_log(GPR_INFO, "Shutting down server");  grpc_server_shutdown_and_notify(server, cq, NULL);  grpc_completion_queue_shutdown(cq);  const gpr_timespec cq_deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5);  grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, NULL);  GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);  grpc_server_destroy(server);  grpc_completion_queue_destroy(cq);  grpc_server_credentials_release(ssl_creds);  gpr_slice_unref(cert_slice);  gpr_slice_unref(key_slice);  gpr_slice_unref(ca_slice);}

static void test_threading_wakeup(grpc_exec_ctx *exec_ctx, void *arg,                                  grpc_error *error) {  threading_shared *shared = arg;  ++shared->wakeups;  ++thread_wakeups;  if (error == GRPC_ERROR_NONE) {    GPR_ASSERT(GRPC_LOG_IF_ERROR(        "consume_wakeup", grpc_wakeup_fd_consume_wakeup(shared->wakeup_fd)));    grpc_fd_notify_on_read(exec_ctx, shared->wakeup_desc, &shared->on_wakeup);    GPR_ASSERT(GRPC_LOG_IF_ERROR("wakeup_next",                                 grpc_wakeup_fd_wakeup(shared->wakeup_fd)));  }}

int main(int argc, char **argv) {  int sock;  grpc_test_init(argc, argv);  sock = socket(PF_INET, SOCK_STREAM, 0);  GPR_ASSERT(sock > 0);  GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_nonblocking",                               grpc_set_socket_nonblocking(sock, 1)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_nonblocking",                               grpc_set_socket_nonblocking(sock, 0)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_cloexec",                               grpc_set_socket_cloexec(sock, 1)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_cloexec",                               grpc_set_socket_cloexec(sock, 0)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_reuse_addr",                               grpc_set_socket_reuse_addr(sock, 1)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_reuse_addr",                               grpc_set_socket_reuse_addr(sock, 0)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_low_latency",                               grpc_set_socket_low_latency(sock, 1)));  GPR_ASSERT(GRPC_LOG_IF_ERROR("set_socket_low_latency",                               grpc_set_socket_low_latency(sock, 0)));  close(sock);  return 0;}

static void do_kick_all(grpc_exec_ctx *exec_ctx, void *arg,                        grpc_error *error_unused) {  grpc_error *error = GRPC_ERROR_NONE;  grpc_pollset *pollset = arg;  gpr_mu_lock(&pollset->pollable.po.mu);  if (pollset->root_worker != NULL) {    grpc_pollset_worker *worker = pollset->root_worker;    do {      if (worker->pollable != &pollset->pollable) {        gpr_mu_lock(&worker->pollable->po.mu);      }      if (worker->initialized_cv) {        worker->kicked = true;        gpr_cv_signal(&worker->cv);      } else {        append_error(&error, grpc_wakeup_fd_wakeup(&worker->pollable->wakeup),                     "pollset_shutdown");      }      if (worker->pollable != &pollset->pollable) {        gpr_mu_unlock(&worker->pollable->po.mu);      }      worker = worker->links[PWL_POLLSET].next;    } while (worker != pollset->root_worker);  }  pollset->kick_alls_pending--;  pollset_maybe_finish_shutdown(exec_ctx, pollset);  gpr_mu_unlock(&pollset->pollable.po.mu);  GRPC_LOG_IF_ERROR("kick_all", error);}

static void inc_on_failure(grpc_exec_ctx *exec_ctx, void *arg,                           grpc_error *error) {  gpr_mu_lock(g_mu);  *(int *)arg += (error != GRPC_ERROR_NONE);  GPR_ASSERT(GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(g_pollset, NULL)));  gpr_mu_unlock(g_mu);}

static void wakeup(grpc_exec_ctx *exec_ctx, grpc_workqueue *workqueue) {  GPR_TIMER_MARK("workqueue.wakeup", 0);  grpc_error *err = grpc_wakeup_fd_wakeup(&workqueue->wakeup_fd);  if (!GRPC_LOG_IF_ERROR("wakeupfd_wakeup", err)) {    drain(exec_ctx, workqueue);  }}

static void on_jwt_verification_done(grpc_exec_ctx *exec_ctx, void *user_data,                                     grpc_jwt_verifier_status status,                                     grpc_jwt_claims *claims) {  synchronizer *sync = user_data;  sync->success = (status == GRPC_JWT_VERIFIER_OK);  if (sync->success) {    char *claims_str;    GPR_ASSERT(claims != NULL);    claims_str =        grpc_json_dump_to_string((grpc_json *)grpc_jwt_claims_json(claims), 2);    printf("Claims: /n/n%s/n", claims_str);    gpr_free(claims_str);    grpc_jwt_claims_destroy(exec_ctx, claims);  } else {    GPR_ASSERT(claims == NULL);    fprintf(stderr, "Verification failed with error %s/n",            grpc_jwt_verifier_status_to_string(status));  }  gpr_mu_lock(sync->mu);  sync->is_done = 1;  GRPC_LOG_IF_ERROR("pollset_kick", grpc_pollset_kick(sync->pollset, NULL));  gpr_mu_unlock(sync->mu);}

static void tcp_connect(grpc_exec_ctx *exec_ctx, const struct sockaddr *remote,                        socklen_t remote_len, on_connect_result *result) {  gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10);  int clifd = socket(remote->sa_family, SOCK_STREAM, 0);  int nconnects_before;  gpr_mu_lock(g_mu);  nconnects_before = g_nconnects;  on_connect_result_init(&g_result);  GPR_ASSERT(clifd >= 0);  gpr_log(GPR_DEBUG, "start connect");  GPR_ASSERT(connect(clifd, remote, remote_len) == 0);  gpr_log(GPR_DEBUG, "wait");  while (g_nconnects == nconnects_before &&         gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) > 0) {    grpc_pollset_worker *worker = NULL;    GPR_ASSERT(GRPC_LOG_IF_ERROR(        "pollset_work",        grpc_pollset_work(exec_ctx, g_pollset, &worker,                          gpr_now(GPR_CLOCK_MONOTONIC), deadline)));    gpr_mu_unlock(g_mu);    grpc_exec_ctx_finish(exec_ctx);    gpr_mu_lock(g_mu);  }  gpr_log(GPR_DEBUG, "wait done");  GPR_ASSERT(g_nconnects == nconnects_before + 1);  close(clifd);  *result = g_result;  gpr_mu_unlock(g_mu);}

static void pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,                           grpc_fd *fd) {  gpr_mu_lock(&pollset->pollable.po.mu);  grpc_error *error = pollset_add_fd_locked(exec_ctx, pollset, fd, false);  gpr_mu_unlock(&pollset->pollable.po.mu);  GRPC_LOG_IF_ERROR("pollset_add_fd", error);}

void create_jwt(const char *json_key_file_path, const char *service_url,                const char *scope) {  grpc_auth_json_key key;  char *jwt;  grpc_slice json_key_data;  GPR_ASSERT(GRPC_LOG_IF_ERROR(      "load_file", grpc_load_file(json_key_file_path, 1, &json_key_data)));  key = grpc_auth_json_key_create_from_string(      (const char *)GRPC_SLICE_START_PTR(json_key_data));  grpc_slice_unref(json_key_data);  if (!grpc_auth_json_key_is_valid(&key)) {    fprintf(stderr, "Could not parse json key./n");    exit(1);  }  jwt = grpc_jwt_encode_and_sign(      &key, service_url == NULL ? GRPC_JWT_OAUTH2_AUDIENCE : service_url,      grpc_max_auth_token_lifetime(), scope);  grpc_auth_json_key_destruct(&key);  if (jwt == NULL) {    fprintf(stderr, "Could not create JWT./n");    exit(1);  }  fprintf(stdout, "%s/n", jwt);  gpr_free(jwt);}

static grpc_call *grpc_channel_create_call_internal(    grpc_exec_ctx *exec_ctx, grpc_channel *channel, grpc_call *parent_call,    uint32_t propagation_mask, grpc_completion_queue *cq,    grpc_pollset_set *pollset_set_alternative, grpc_mdelem path_mdelem,    grpc_mdelem authority_mdelem, gpr_timespec deadline) {  grpc_mdelem send_metadata[2];  size_t num_metadata = 0;  GPR_ASSERT(channel->is_client);  GPR_ASSERT(!(cq != NULL && pollset_set_alternative != NULL));  send_metadata[num_metadata++] = path_mdelem;  if (!GRPC_MDISNULL(authority_mdelem)) {    send_metadata[num_metadata++] = authority_mdelem;  } else if (!GRPC_MDISNULL(channel->default_authority)) {    send_metadata[num_metadata++] = GRPC_MDELEM_REF(channel->default_authority);  }  grpc_call_create_args args;  memset(&args, 0, sizeof(args));  args.channel = channel;  args.parent_call = parent_call;  args.propagation_mask = propagation_mask;  args.cq = cq;  args.pollset_set_alternative = pollset_set_alternative;  args.server_transport_data = NULL;  args.add_initial_metadata = send_metadata;  args.add_initial_metadata_count = num_metadata;  args.send_deadline = deadline;  grpc_call *call;  GRPC_LOG_IF_ERROR("call_create", grpc_call_create(exec_ctx, &args, &call));  return call;}

static void read_and_write_test_write_handler(grpc_exec_ctx *exec_ctx,                                              void *data, grpc_error *error) {  struct read_and_write_test_state *state = data;  grpc_slice *slices = NULL;  size_t nslices;  if (error == GRPC_ERROR_NONE) {    state->bytes_written += state->current_write_size;    if (state->target_bytes - state->bytes_written <        state->current_write_size) {      state->current_write_size = state->target_bytes - state->bytes_written;    }    if (state->current_write_size != 0) {      slices = allocate_blocks(state->current_write_size, 8192, &nslices,                               &state->current_write_data);      grpc_slice_buffer_reset_and_unref(&state->outgoing);      grpc_slice_buffer_addn(&state->outgoing, slices, nslices);      grpc_endpoint_write(exec_ctx, state->write_ep, &state->outgoing,                          &state->done_write);      gpr_free(slices);      return;    }  }  gpr_log(GPR_INFO, "Write handler done");  gpr_mu_lock(g_mu);  state->write_done = 1 + (error == GRPC_ERROR_NONE);  GRPC_LOG_IF_ERROR("pollset_kick", grpc_pollset_kick(g_pollset, NULL));  gpr_mu_unlock(g_mu);}

static void actually_poll(void *argsp) {  args_struct *args = argsp;  gpr_timespec deadline = n_sec_deadline(10);  while (true) {    bool done = gpr_atm_acq_load(&args->done_atm) != 0;    if (done) {      break;    }    gpr_timespec time_left =        gpr_time_sub(deadline, gpr_now(GPR_CLOCK_REALTIME));    gpr_log(GPR_DEBUG, "done=%d, time_left=%" PRId64 ".%09d", done,            time_left.tv_sec, time_left.tv_nsec);    GPR_ASSERT(gpr_time_cmp(time_left, gpr_time_0(GPR_TIMESPAN)) >= 0);    grpc_pollset_worker *worker = NULL;    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;    gpr_mu_lock(args->mu);    GRPC_LOG_IF_ERROR(        "pollset_work",        grpc_pollset_work(&exec_ctx, args->pollset, &worker,                          gpr_now(GPR_CLOCK_REALTIME), n_sec_deadline(1)));    gpr_mu_unlock(args->mu);    grpc_exec_ctx_finish(&exec_ctx);  }  gpr_event_set(&args->ev, (void *)1);}

static void on_oauth2_response(grpc_exec_ctx *exec_ctx, void *user_data,                               grpc_credentials_md *md_elems, size_t num_md,                               grpc_credentials_status status,                               const char *error_details) {  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(request->mu);  request->is_done = 1;  request->token = token;  GRPC_LOG_IF_ERROR(      "pollset_kick",      grpc_pollset_kick(grpc_polling_entity_pollset(&request->pops), NULL));  gpr_mu_unlock(request->mu);}

static void lr_start_transport_stream_op_batch(    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,    grpc_transport_stream_op_batch *op) {  GPR_TIMER_BEGIN("lr_start_transport_stream_op_batch", 0);  call_data *calld = (call_data *)elem->call_data;  if (op->recv_initial_metadata) {    /* substitute our callback for the higher callback */    calld->recv_initial_metadata =        op->payload->recv_initial_metadata.recv_initial_metadata;    calld->ops_recv_initial_metadata_ready =        op->payload->recv_initial_metadata.recv_initial_metadata_ready;    op->payload->recv_initial_metadata.recv_initial_metadata_ready =        &calld->on_initial_md_ready;  } else if (op->send_trailing_metadata) {    GRPC_LOG_IF_ERROR(        "grpc_metadata_batch_filter",        grpc_metadata_batch_filter(            exec_ctx,            op->payload->send_trailing_metadata.send_trailing_metadata,            lr_trailing_md_filter, elem,            "LR trailing metadata filtering error"));  }  grpc_call_next_op(exec_ctx, elem, op);  GPR_TIMER_END("lr_start_transport_stream_op_batch", 0);}

static void finish_connection(grpc_exec_ctx *exec_ctx) {  gpr_mu_lock(g_mu);  g_connections_complete++;  GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",                               grpc_pollset_kick(exec_ctx, g_pollset, NULL)));  gpr_mu_unlock(g_mu);}

static void on_compute_engine_detection_http_response(grpc_exec_ctx *exec_ctx,                                                      void *user_data,                                                      grpc_error *error) {  compute_engine_detector *detector = (compute_engine_detector *)user_data;  if (error == GRPC_ERROR_NONE && detector->response.status == 200 &&      detector->response.hdr_count > 0) {    /* Internet providers can return a generic response to all requests, so       it is necessary to check that metadata header is present also. */    size_t i;    for (i = 0; i < detector->response.hdr_count; i++) {      grpc_http_header *header = &detector->response.hdrs[i];      if (strcmp(header->key, "Metadata-Flavor") == 0 &&          strcmp(header->value, "Google") == 0) {        detector->success = 1;        break;      }    }  }  gpr_mu_lock(g_polling_mu);  detector->is_done = 1;  GRPC_LOG_IF_ERROR(      "Pollset kick",      grpc_pollset_kick(grpc_polling_entity_pollset(&detector->pollent), NULL));  gpr_mu_unlock(g_polling_mu);}

/* Called when a client upload session is ready to shutdown. */static void client_session_shutdown_cb(grpc_exec_ctx *exec_ctx,                                       void *arg /*client */, int success) {  client *cl = arg;  grpc_fd_orphan(exec_ctx, cl->em_fd, NULL, NULL, "c");  cl->done = 1;  GPR_ASSERT(      GRPC_LOG_IF_ERROR("pollset_kick", grpc_pollset_kick(g_pollset, NULL)));}

/* Write to a socket using the grpc_tcp API, then drain it directly.   Note that if the write does not complete immediately we need to drain the   socket in parallel with the read. */static void write_test(size_t num_bytes, size_t slice_size) {  int sv[2];  grpc_endpoint *ep;  struct write_socket_state state;  size_t num_blocks;  grpc_slice *slices;  uint8_t current_data = 0;  grpc_slice_buffer outgoing;  grpc_closure write_done_closure;  gpr_timespec deadline = grpc_timeout_seconds_to_deadline(20);  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  gpr_log(GPR_INFO,          "Start write test with %" PRIuPTR " bytes, slice size %" PRIuPTR,          num_bytes, slice_size);  create_sockets(sv);  grpc_resource_quota *resource_quota =      grpc_resource_quota_create("write_test");  ep = grpc_tcp_create(grpc_fd_create(sv[1], "write_test"), resource_quota,                       GRPC_TCP_DEFAULT_READ_SLICE_SIZE, "test");  grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);  grpc_endpoint_add_to_pollset(&exec_ctx, ep, g_pollset);  state.ep = ep;  state.write_done = 0;  slices = allocate_blocks(num_bytes, slice_size, &num_blocks, &current_data);  grpc_slice_buffer_init(&outgoing);  grpc_slice_buffer_addn(&outgoing, slices, num_blocks);  grpc_closure_init(&write_done_closure, write_done, &state,                    grpc_schedule_on_exec_ctx);  grpc_endpoint_write(&exec_ctx, ep, &outgoing, &write_done_closure);  drain_socket_blocking(sv[0], num_bytes, num_bytes);  gpr_mu_lock(g_mu);  for (;;) {    grpc_pollset_worker *worker = NULL;    if (state.write_done) {      break;    }    GPR_ASSERT(GRPC_LOG_IF_ERROR(        "pollset_work",        grpc_pollset_work(&exec_ctx, g_pollset, &worker,                          gpr_now(GPR_CLOCK_MONOTONIC), deadline)));    gpr_mu_unlock(g_mu);    grpc_exec_ctx_finish(&exec_ctx);    gpr_mu_lock(g_mu);  }  gpr_mu_unlock(g_mu);  grpc_slice_buffer_destroy_internal(&exec_ctx, &outgoing);  grpc_endpoint_destroy(&exec_ctx, ep);  gpr_free(slices);  grpc_exec_ctx_finish(&exec_ctx);}

int main(int argc, char **argv) {  int result = 0;  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  synchronizer sync;  grpc_channel_credentials *creds = NULL;  char *service_url = "https://test.foo.google.com/Foo";  grpc_auth_metadata_context context;  gpr_cmdline *cl = gpr_cmdline_create("print_google_default_creds_token");  gpr_cmdline_add_string(cl, "service_url",                         "Service URL for the token request.", &service_url);  gpr_cmdline_parse(cl, argc, argv);  memset(&context, 0, sizeof(context));  context.service_url = service_url;  grpc_init();  creds = grpc_google_default_credentials_create();  if (creds == NULL) {    fprintf(stderr, "/nCould not find default credentials./n/n");    result = 1;    goto end;  }  grpc_pollset *pollset = gpr_malloc(grpc_pollset_size());  grpc_pollset_init(pollset, &sync.mu);  sync.pops = grpc_polling_entity_create_from_pollset(pollset);  sync.is_done = 0;  grpc_call_credentials_get_request_metadata(      &exec_ctx, ((grpc_composite_channel_credentials *)creds)->call_creds,      &sync.pops, context, on_metadata_response, &sync);  gpr_mu_lock(sync.mu);  while (!sync.is_done) {    grpc_pollset_worker *worker = NULL;    if (!GRPC_LOG_IF_ERROR(            "pollset_work",            grpc_pollset_work(&exec_ctx,                              grpc_polling_entity_pollset(&sync.pops), &worker,                              gpr_now(GPR_CLOCK_MONOTONIC),                              gpr_inf_future(GPR_CLOCK_MONOTONIC))))      sync.is_done = 1;    gpr_mu_unlock(sync.mu);    grpc_exec_ctx_flush(&exec_ctx);    gpr_mu_lock(sync.mu);  }  gpr_mu_unlock(sync.mu);  grpc_exec_ctx_finish(&exec_ctx);  grpc_channel_credentials_release(creds);  gpr_free(grpc_polling_entity_pollset(&sync.pops));end:  gpr_cmdline_destroy(cl);  grpc_shutdown();  return result;}

/* pollset_shutdown is guaranteed to be called before pollset_destroy. */static void pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {  pollable_destroy(&pollset->pollable);  if (pollset_is_pollable_fd(pollset, pollset->current_pollable)) {    UNREF_BY(exec_ctx, (grpc_fd *)pollset->current_pollable, 2,             "pollset_pollable");  }  GRPC_LOG_IF_ERROR("pollset_process_events",                    pollset_process_events(exec_ctx, pollset, true));}

static grpc_call_credentials *create_refresh_token_creds(    const char *json_refresh_token_file_path) {  grpc_slice refresh_token;  GPR_ASSERT(GRPC_LOG_IF_ERROR(      "load_file",      grpc_load_file(json_refresh_token_file_path, 1, &refresh_token)));  return grpc_google_refresh_token_credentials_create(      (const char *)GRPC_SLICE_START_PTR(refresh_token), NULL);}

void bad_server_thread(void *vargs) {  struct server_thread_args *args = (struct server_thread_args *)vargs;  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;  grpc_resolved_address resolved_addr;  struct sockaddr_storage *addr = (struct sockaddr_storage *)resolved_addr.addr;  int port;  grpc_tcp_server *s;  grpc_error *error = grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s);  GPR_ASSERT(error == GRPC_ERROR_NONE);  memset(&resolved_addr, 0, sizeof(resolved_addr));  addr->ss_family = AF_INET;  error = grpc_tcp_server_add_port(s, &resolved_addr, &port);  GPR_ASSERT(GRPC_LOG_IF_ERROR("grpc_tcp_server_add_port", error));  GPR_ASSERT(port > 0);  gpr_asprintf(&args->addr, "localhost:%d", port);  grpc_tcp_server_start(&exec_ctx, s, &args->pollset, 1, on_connect, args);  gpr_event_set(&args->ready, (void *)1);  gpr_mu_lock(args->mu);  while (gpr_atm_acq_load(&args->stop) == 0) {    gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);    gpr_timespec deadline =        gpr_time_add(now, gpr_time_from_millis(100, GPR_TIMESPAN));    grpc_pollset_worker *worker = NULL;    if (!GRPC_LOG_IF_ERROR("pollset_work",                           grpc_pollset_work(&exec_ctx, args->pollset, &worker,                                             now, deadline))) {      gpr_atm_rel_store(&args->stop, 1);    }    gpr_mu_unlock(args->mu);    grpc_exec_ctx_finish(&exec_ctx);    gpr_mu_lock(args->mu);  }  gpr_mu_unlock(args->mu);  grpc_tcp_server_unref(&exec_ctx, s);  grpc_exec_ctx_finish(&exec_ctx);  gpr_free(args->addr);}

static void test_threading(void) {  threading_shared shared;  shared.pollset = gpr_zalloc(grpc_pollset_size());  grpc_pollset_init(shared.pollset, &shared.mu);  gpr_thd_id thds[10];  for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {    gpr_thd_options opt = gpr_thd_options_default();    gpr_thd_options_set_joinable(&opt);    gpr_thd_new(&thds[i], test_threading_loop, &shared, &opt);  }  grpc_wakeup_fd fd;  GPR_ASSERT(GRPC_LOG_IF_ERROR("wakeup_fd_init", grpc_wakeup_fd_init(&fd)));  shared.wakeup_fd = &fd;  shared.wakeup_desc = grpc_fd_create(fd.read_fd, "wakeup");  shared.wakeups = 0;  {    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;    grpc_pollset_add_fd(&exec_ctx, shared.pollset, shared.wakeup_desc);    grpc_fd_notify_on_read(        &exec_ctx, shared.wakeup_desc,        GRPC_CLOSURE_INIT(&shared.on_wakeup, test_threading_wakeup, &shared,                          grpc_schedule_on_exec_ctx));    grpc_exec_ctx_finish(&exec_ctx);  }  GPR_ASSERT(GRPC_LOG_IF_ERROR("wakeup_first",                               grpc_wakeup_fd_wakeup(shared.wakeup_fd)));  for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {    gpr_thd_join(thds[i]);  }  fd.read_fd = 0;  grpc_wakeup_fd_destroy(&fd);  {    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;    grpc_fd_shutdown(&exec_ctx, shared.wakeup_desc, GRPC_ERROR_CANCELLED);    grpc_fd_orphan(&exec_ctx, shared.wakeup_desc, NULL, NULL,                   false /* already_closed */, "done");    grpc_pollset_shutdown(&exec_ctx, shared.pollset,                          GRPC_CLOSURE_CREATE(destroy_pollset, shared.pollset,                                              grpc_schedule_on_exec_ctx));    grpc_exec_ctx_finish(&exec_ctx);  }  gpr_free(shared.pollset);}

static void got_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,                                 grpc_error *error) {  size_t i;  int port = 0;  portreq *pr = arg;  int failed = 0;  grpc_httpcli_response *response = &pr->response;  if (error != GRPC_ERROR_NONE) {    failed = 1;    const char *msg = grpc_error_string(error);    gpr_log(GPR_DEBUG, "failed port pick from server: retrying [%s]", msg);    grpc_error_free_string(msg);  } else if (response->status != 200) {    failed = 1;    gpr_log(GPR_DEBUG, "failed port pick from server: status=%d",            response->status);  }  if (failed) {    grpc_httpcli_request req;    memset(&req, 0, sizeof(req));    GPR_ASSERT(pr->retries < 10);    gpr_sleep_until(gpr_time_add(        gpr_now(GPR_CLOCK_REALTIME),        gpr_time_from_millis(            (int64_t)(1000.0 * (1 + pow(1.3, pr->retries) * rand() / RAND_MAX)),            GPR_TIMESPAN)));    pr->retries++;    req.host = pr->server;    req.http.path = "/get";    grpc_http_response_destroy(&pr->response);    memset(&pr->response, 0, sizeof(pr->response));    grpc_resource_quota *resource_quota =        grpc_resource_quota_create("port_server_client/pick_retry");    grpc_httpcli_get(exec_ctx, pr->ctx, &pr->pops, resource_quota, &req,                     GRPC_TIMEOUT_SECONDS_TO_DEADLINE(10),                     grpc_closure_create(got_port_from_server, pr),                     &pr->response);    grpc_resource_quota_internal_unref(exec_ctx, resource_quota);    return;  }  GPR_ASSERT(response);  GPR_ASSERT(response->status == 200);  for (i = 0; i < response->body_length; i++) {    GPR_ASSERT(response->body[i] >= '0' && response->body[i] <= '9');    port = port * 10 + response->body[i] - '0';  }  GPR_ASSERT(port > 1024);  gpr_mu_lock(pr->mu);  pr->port = port;  GRPC_LOG_IF_ERROR(      "pollset_kick",      grpc_pollset_kick(grpc_polling_entity_pollset(&pr->pops), NULL));  gpr_mu_unlock(pr->mu);}

static void freed_port_from_server(grpc_exec_ctx *exec_ctx, void *arg,                                   grpc_error *error) {  freereq *pr = arg;  gpr_mu_lock(pr->mu);  pr->done = 1;  GRPC_LOG_IF_ERROR(      "pollset_kick",      grpc_pollset_kick(grpc_polling_entity_pollset(&pr->pops), NULL));  gpr_mu_unlock(pr->mu);}

static void init(void) {#ifndef GPR_MANYLINUX1  int s = socket(AF_INET, SOCK_STREAM, 0);  if (s >= 0) {    has_so_reuseport = GRPC_LOG_IF_ERROR("check for SO_REUSEPORT",                                         grpc_set_socket_reuse_port(s, 1));    close(s);  }#endif}

int main(int argc, char **argv) {  gpr_slice buffer;  squelch = false;  leak_check = false;  GPR_ASSERT(      GRPC_LOG_IF_ERROR("load_file", grpc_load_file(argv[1], 0, &buffer)));  LLVMFuzzerTestOneInput(GPR_SLICE_START_PTR(buffer), GPR_SLICE_LENGTH(buffer));  gpr_slice_unref(buffer);  return 0;}